kpad.h

Go to the documentation of this file.

#pragma once
#include <wut.h>
#include <padscore/wpad.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef enum WPADChan KPADChan;
typedef enum WPADDataFormat KPADDataFormat;
typedef enum WPADExtensionType KPADExtensionType;
typedef enum WPADMplsMode KPADMplsMode;
 
typedef struct KPADStatus KPADStatus;
typedef struct KPADUnifiedWpadStatus KPADUnifiedWpadStatus;
typedef struct KPADVec2D KPADVec2D;
typedef struct KPADVec3D KPADVec3D;
 
typedef enum KPADError
{
   KPAD_ERROR_OK                 = 0,
   KPAD_ERROR_NO_SAMPLES         = -1,
   KPAD_ERROR_INVALID_CONTROLLER = -2,
   KPAD_ERROR_WPAD_UNINIT        = -3,
   KPAD_ERROR_BUSY               = -4,
   KPAD_ERROR_UNINITIALIZED      = -5,
} KPADError;
 
typedef enum KPADControlMplsStatus
{
   KPAD_CONTROL_MPLS_STATUS_STARTED = 0,
   KPAD_CONTROL_MPLS_STATUS_FINISHED = 1,
   KPAD_CONTROL_MPLS_STATUS_FAILED_MPLS_ONLY = -1,
   KPAD_CONTROL_MPLS_STATUS_FAILED_MPLS_NUNCHUK = -2,
   KPAD_CONTROL_MPLS_STATUS_FAILED_MPLS_CLASSIC = -3,
} KPADControlMplsStatus;
 
struct KPADVec2D
{
   float x;
   float y;
};
WUT_CHECK_OFFSET(KPADVec2D, 0x00, x);
WUT_CHECK_OFFSET(KPADVec2D, 0x04, y);
WUT_CHECK_SIZE(KPADVec2D, 0x08);
 
struct KPADVec3D
{
   float x;
   float y;
   float z;
};
WUT_CHECK_OFFSET(KPADVec3D, 0x00, x);
WUT_CHECK_OFFSET(KPADVec3D, 0x04, y);
WUT_CHECK_OFFSET(KPADVec3D, 0x08, z);
WUT_CHECK_SIZE(KPADVec3D, 0x0C);
 
struct KPADStatus
{
   uint32_t hold;
 
   uint32_t trigger;
 
   uint32_t release;
 
   KPADVec3D acc;
 
   float accMagnitude;
 
   float accVariation;
 
   KPADVec2D pos;
 
   KPADVec2D posDiff;
 
   float posDiffMagnitude;
 
   KPADVec2D angle;
 
   KPADVec2D angleDiff;
 
   float angleDiffMagnitude;
 
   float dist;
 
   float distDiff;
 
   float distDiffMagnitude;
 
   KPADVec2D down;
 
   uint8_t extensionType;
 
   int8_t error;
 
   int8_t posValid;
 
   uint8_t format;
 
   union
   {
      struct
      {
         KPADVec2D stick;
         KPADVec3D acc;
         float accMagnitude;
         float accVariation;
         uint32_t hold;
         uint32_t trigger;
         uint32_t release;
      } nunchuk;
 
      struct
      {
         uint32_t hold;
         uint32_t trigger;
         uint32_t release;
         KPADVec2D leftStick;
         KPADVec2D rightStick;
         float leftTrigger;
         float rightTrigger;
      } classic;
 
      struct
      {
         uint32_t hold;
         uint32_t trigger;
         uint32_t release;
         KPADVec2D leftStick;
         KPADVec2D rightStick;
         int32_t charging;
         int32_t wired;
      } pro;
 
      struct
      {
         double  avgTGCWeight;
         double  weights[WPAD_MAX_PRESSURE_SENSORS];
         double  avgWeights[WPAD_MAX_PRESSURE_SENSORS];
         int32_t error;
         int32_t calibration;
      } balance;
   };
 
   struct
   {
      KPADVec3D acc;
      KPADVec3D angles;
      KPADVec3D dirX;
      KPADVec3D dirY;
      KPADVec3D dirZ;
   } mplus;
 
   WUT_PADDING_BYTES(4);
};
WUT_CHECK_OFFSET(KPADStatus, 0x00, hold);
WUT_CHECK_OFFSET(KPADStatus, 0x04, trigger);
WUT_CHECK_OFFSET(KPADStatus, 0x08, release);
WUT_CHECK_OFFSET(KPADStatus, 0x0C, acc);
WUT_CHECK_OFFSET(KPADStatus, 0x18, accMagnitude);
WUT_CHECK_OFFSET(KPADStatus, 0x1C, accVariation);
WUT_CHECK_OFFSET(KPADStatus, 0x20, pos);
WUT_CHECK_OFFSET(KPADStatus, 0x28, posDiff);
WUT_CHECK_OFFSET(KPADStatus, 0x30, posDiffMagnitude);
WUT_CHECK_OFFSET(KPADStatus, 0x34, angle);
WUT_CHECK_OFFSET(KPADStatus, 0x3C, angleDiff);
WUT_CHECK_OFFSET(KPADStatus, 0x44, angleDiffMagnitude);
WUT_CHECK_OFFSET(KPADStatus, 0x48, dist);
WUT_CHECK_OFFSET(KPADStatus, 0x4C, distDiff);
WUT_CHECK_OFFSET(KPADStatus, 0x50, distDiffMagnitude);
WUT_CHECK_OFFSET(KPADStatus, 0x54, down);
WUT_CHECK_OFFSET(KPADStatus, 0x5C, extensionType);
WUT_CHECK_OFFSET(KPADStatus, 0x5D, error);
WUT_CHECK_OFFSET(KPADStatus, 0x5E, posValid);
WUT_CHECK_OFFSET(KPADStatus, 0x5F, format);
// Nunchuk fields.
WUT_CHECK_OFFSET(KPADStatus, 0x60, nunchuk.stick);
WUT_CHECK_OFFSET(KPADStatus, 0x68, nunchuk.acc);
WUT_CHECK_OFFSET(KPADStatus, 0x74, nunchuk.accMagnitude);
WUT_CHECK_OFFSET(KPADStatus, 0x78, nunchuk.accVariation);
WUT_CHECK_OFFSET(KPADStatus, 0x7C, nunchuk.hold);
WUT_CHECK_OFFSET(KPADStatus, 0x80, nunchuk.trigger);
WUT_CHECK_OFFSET(KPADStatus, 0x84, nunchuk.release);
// Classic fields.
WUT_CHECK_OFFSET(KPADStatus, 0x60, classic.hold);
WUT_CHECK_OFFSET(KPADStatus, 0x64, classic.trigger);
WUT_CHECK_OFFSET(KPADStatus, 0x68, classic.release);
WUT_CHECK_OFFSET(KPADStatus, 0x6C, classic.leftStick);
WUT_CHECK_OFFSET(KPADStatus, 0x74, classic.rightStick);
WUT_CHECK_OFFSET(KPADStatus, 0x7C, classic.leftTrigger);
WUT_CHECK_OFFSET(KPADStatus, 0x80, classic.rightTrigger);
// Pro fields.
WUT_CHECK_OFFSET(KPADStatus, 0x60, pro.hold);
WUT_CHECK_OFFSET(KPADStatus, 0x64, pro.trigger);
WUT_CHECK_OFFSET(KPADStatus, 0x68, pro.release);
WUT_CHECK_OFFSET(KPADStatus, 0x6C, pro.leftStick);
WUT_CHECK_OFFSET(KPADStatus, 0x74, pro.rightStick);
WUT_CHECK_OFFSET(KPADStatus, 0x7C, pro.charging);
WUT_CHECK_OFFSET(KPADStatus, 0x80, pro.wired);
// Balance Board fields.
WUT_CHECK_OFFSET(KPADStatus, 0x60, balance.avgTGCWeight);
WUT_CHECK_OFFSET(KPADStatus, 0x68, balance.weights);
WUT_CHECK_OFFSET(KPADStatus, 0x88, balance.avgWeights);
WUT_CHECK_OFFSET(KPADStatus, 0xA8, balance.error);
WUT_CHECK_OFFSET(KPADStatus, 0xAC, balance.calibration);
// MotionPlus fields.
WUT_CHECK_OFFSET(KPADStatus, 0xB0, mplus.acc);
WUT_CHECK_OFFSET(KPADStatus, 0xBC, mplus.angles);
WUT_CHECK_OFFSET(KPADStatus, 0xC8, mplus.dirX);
WUT_CHECK_OFFSET(KPADStatus, 0xD4, mplus.dirY);
WUT_CHECK_OFFSET(KPADStatus, 0xE0, mplus.dirZ);
WUT_CHECK_SIZE(KPADStatus, 0xF0);
 
struct KPADUnifiedWpadStatus {
   union {
      WPADStatus             core;
      WPADStatusNunchuk      nunchuk;
      WPADStatusClassic      classic;
      WPADStatusPro          pro;
      WPADStatusBalanceBoard balance;
      WPADStatusTrain        train;
   };
   uint8_t format;
   WUT_PADDING_BYTES(3);
};
WUT_CHECK_OFFSET(KPADUnifiedWpadStatus, 0x00, core);
WUT_CHECK_OFFSET(KPADUnifiedWpadStatus, 0x00, nunchuk);
WUT_CHECK_OFFSET(KPADUnifiedWpadStatus, 0x00, classic);
WUT_CHECK_OFFSET(KPADUnifiedWpadStatus, 0x00, pro);
WUT_CHECK_OFFSET(KPADUnifiedWpadStatus, 0x00, balance);
WUT_CHECK_OFFSET(KPADUnifiedWpadStatus, 0x00, train);
WUT_CHECK_OFFSET(KPADUnifiedWpadStatus, 0x40, format);
WUT_CHECK_SIZE(KPADUnifiedWpadStatus, 0x44);
 
typedef WPADConnectCallback KPADConnectCallback;
typedef WPADSamplingCallback KPADSamplingCallback;
 
typedef void (*KPADControlMplsCallback)(KPADChan chan, KPADControlMplsStatus status);
 
void
KPADInit(void);
 
void
KPADInitEx(KPADUnifiedWpadStatus *buffer,
           uint32_t count);
 
void
KPADShutdown(void);
 
uint32_t
KPADRead(KPADChan chan,
         KPADStatus *data,
         uint32_t size);
 
uint32_t
KPADReadEx(KPADChan chan,
           KPADStatus *data,
           uint32_t size,
           KPADError *error);
 
void
KPADGetUnifiedWpadStatus(KPADChan chan,
                         KPADUnifiedWpadStatus *buffer,
                         uint32_t count);
 
int32_t
KPADSetMaxControllers(uint32_t maxControllers);
 
uint32_t
KPADGetMaxControllers(void);
 
uint32_t
KPADGetGameMaxControllers(void);
 
KPADConnectCallback
KPADSetConnectCallback(KPADChan chan,
                       KPADConnectCallback callback);
 
KPADSamplingCallback
KPADSetSamplingCallback(KPADChan channel,
                        KPADSamplingCallback callback);
 
uint32_t
KPADGetMplsWorkSize(void);
 
void
KPADSetMplsWorkarea(void *buf);
 
void
KPADSetControlMplsCallback(KPADChan chan,
                           KPADControlMplsCallback callback);
 
void
KPADEnableMpls(KPADChan channel,
               KPADMplsMode mode);
 
void
KPADDisableMpls(KPADChan channel);
 
KPADMplsMode
KPADGetMplsStatus(KPADChan chan);
 
void
KPADResetMpls(KPADChan chan);
 
void
KPADEnableDPD(KPADChan chan);
 
void
KPADDisableDPD(KPADChan chan);
 
void
KPADResetWbcZeroPoint(void);
 
void
KPADResetWbcTgcWeight(void);
 
#ifdef __cplusplus
}
#endif