The-Homebrew-Cloud/controller_patcher
2
0
Fork 0
mirror of https://github.com/Maschell/controller_patcher.git synced 2024-11-21 19:49:16 +01:00
Code Issues Packages Projects Releases Wiki Activity

Saving the order in which the controllers were connected

Browse Source
This commit is contained in:
Maschell 2017-05-20 19:22:16 +02:00
parent bd4a10baa6
commit 0d419a0064
8 changed files with 78 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

127
ControllerPatcher.cpp
View File

@ -78,8 +78,8 @@ void ControllerPatcher::InitButtonMapping(){
}
void ControllerPatcher::ResetConfig(){
memset(&gControllerMapping,0,sizeof(gControllerMapping));
disableControllerMapping();
memset(connectionOrderHelper,0,sizeof(connectionOrderHelper));
memset(&gControllerMapping,0,sizeof(gControllerMapping)); // Init / Invalid everything
memset(config_controller,CONTROLLER_PATCHER_INVALIDVALUE,sizeof(config_controller)); // Init / Invalid everything
memset(config_controller_hidmask,0,sizeof(config_controller_hidmask)); // Init / Invalid everything
memset(gNetworkController,0,sizeof(gNetworkController)); // Init / Invalid everything
@ -564,6 +564,7 @@ void ControllerPatcher::DeInit(){
memset(config_controller,0,sizeof(config_controller));
memset(config_controller_hidmask,0,sizeof(config_controller_hidmask));
memset(gNetworkController,0,sizeof(gNetworkController));
memset(connectionOrderHelper,0,sizeof(connectionOrderHelper));
memset(gWPADConnectCallback,0,sizeof(gWPADConnectCallback));
memset(gKPADConnectCallback,0,sizeof(gKPADConnectCallback));
@ -762,44 +763,40 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::setRumble(UController_Type
return CONTROLLER_PATCHER_ERROR_NONE;
}
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::gettingInputAllDevicesEx(InputDataEx * output,s32 array_size){
s32 hid = gHIDCurrentDevice;
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::gettingInputAllDevices(InputData * output,s32 array_size){
HID_Data * data_cur;
VPADStatus pad_buffer;
VPADStatus * buffer = &pad_buffer;
s32 result = CONTROLLER_PATCHER_ERROR_NONE;
std::map<my_cb_user *,s32> pad_count;
//printf("fill in data\n");
for(s32 i = 0;i < gHIDMaxDevices;i++){
if(result > array_size){
break;
}
if((hid & (1 << i)) != 0){
memset(buffer,0,sizeof(*buffer));
u8 * status = &output[result].status;
*status = 0;
if(connectionOrderHelper[i] != NULL){
*status = 1;
s32 newhid = (1 << i);
my_cb_user * usr = connectionOrderHelper[i];
pad_count[usr] = pad_count[usr] +1;
s32 hid = usr->slotdata.hidmask;
//printf("result[%d] usr: %08X\n",result,usr);
s32 buttons_hold = 0;
s32 realpad = pad_count[usr] - 1;
output[result].device_info.pad_count = usr->pads_per_device;
output[result].device_info.slotdata = usr->slotdata;
output[result].device_info.vidpid = usr->vidpid;
for(s32 pad = 0;pad<HID_MAX_PADS_COUNT;pad++){
InputButtonData * buttondata = &output[result].button_data;
InputStickData * stickdata = &output[result].stick_data;
u8 * status = &output[result].status;
buttons_hold = 0;
s32 buttons_hold = 0;
buttondata->hold = 0;
buttondata->trigger = 0;
buttondata->release = 0;
result++;
if(result > array_size){
break;
}
s32 res;
if((res = ControllerPatcherHID::getHIDData(newhid,pad,&data_cur)) < 0){
*status = 0;
continue;
}
*status = 1;
if((res = ControllerPatcherHID::getHIDData(hid,realpad,&data_cur)) == 0){
res = ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_A);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_B);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_X);
@ -840,91 +837,17 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::gettingInputAllDevicesEx(I
stickdata->rightStickX = buffer->rightStick.x;
stickdata->rightStickY = buffer->rightStick.y;
data_cur->last_buttons = buttons_hold;
}
}
}
return array_size;
}
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcher::gettingInputAllDevices(InputData * output,s32 array_size){
s32 hid = gHIDCurrentDevice;
HID_Data * data_cur;
VPADStatus pad_buffer;
VPADStatus * buffer = &pad_buffer;
s32 result = CONTROLLER_PATCHER_ERROR_NONE;
for(s32 i = 0;i< gHIDMaxDevices;i++){
if((hid & (1 << i)) != 0){
memset(buffer,0,sizeof(*buffer));
s32 newhid = (1 << i);
s32 deviceslot = ControllerPatcherUtils::getDeviceSlot(newhid);
if(deviceslot < 0) continue;
DeviceInfo * deviceinfo = &(output[result].device_info);
InputButtonData * buttondata = output[result].button_data;
deviceinfo->slotdata.deviceslot = deviceslot;
deviceinfo->slotdata.hidmask = newhid;
deviceinfo->vidpid.vid = config_controller[deviceslot][CONTRPS_VID][0] * 0x100 + config_controller[deviceslot][CONTRPS_VID][1];
deviceinfo->vidpid.pid = config_controller[deviceslot][CONTRPS_PID][0] * 0x100 + config_controller[deviceslot][CONTRPS_PID][1];
/* not needed
if(config_controller[deviceslot][CONTRPS_PAD_COUNT][0] != CONTROLLER_PATCHER_INVALIDVALUE){
deviceinfo->pad_count = config_controller[deviceslot][CONTRPS_PAD_COUNT][1];
}else{
deviceinfo->pad_count = HID_MAX_PADS_COUNT;
}*/
s32 buttons_hold = 0;
for(s32 pad = 0;pad<HID_MAX_PADS_COUNT;pad++){
buttons_hold = 0;
buttondata[pad].hold = 0;
buttondata[pad].trigger = 0;
buttondata[pad].release = 0;
s32 res;
if((res = ControllerPatcherHID::getHIDData(deviceinfo->slotdata.hidmask,pad,&data_cur)) < 0){
continue;
}
res = ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_A);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_B);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_X);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_Y);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_LEFT);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_RIGHT);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_DOWN);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_UP);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_MINUS);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_L);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_R);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_PLUS);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_ZL);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_ZR);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_HOME);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_STICK_L);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_STICK_R);
buttondata[pad].hold |= buttons_hold;
buttondata[pad].trigger |= (buttons_hold & (~(data_cur->last_buttons)));
buttondata[pad].release |= ((data_cur->last_buttons) & (~buttons_hold));
//printf("result[%d] buttons %08X\n",result,buttons_hold);
data_cur->last_buttons = buttons_hold;
}
}
result++;
if(result >= array_size){
break;
}
}
}
return result;
}

1
ControllerPatcher.hpp
View File

@ -217,7 +217,6 @@ class ControllerPatcher{
@return When the functions failed result < 0 is returned. If the result is == 0 the function was successful. If the result is > 0 the number of stored sets in the array is returned.
**/
static CONTROLLER_PATCHER_RESULT_OR_ERROR gettingInputAllDevices(InputData * output,s32 array_size);
static CONTROLLER_PATCHER_RESULT_OR_ERROR gettingInputAllDevicesEx(InputDataEx * output,s32 array_size);
/**
Remaps the buttons in the given \p VPADStatus pointer. InitButtonMapping() needs to be called before calling this. The information about the remapping is stored in the config_controller array.

6
ControllerPatcherWrapper.cpp
View File

@ -16,6 +16,7 @@
****************************************************************************/
#include "controller_patcher/ControllerPatcher.hpp"
#include "controller_patcher/ControllerPatcherWrapper.h"
extern "C" void ControllerPatcherInit(void){
ControllerPatcher::Init();
ControllerPatcher::disableControllerMapping();
@ -23,12 +24,13 @@ extern "C" void ControllerPatcherInit(void){
ControllerPatcher::disableWiiUEnergySetting();
}
extern "C" CONTROLLER_PATCHER_RESULT_OR_ERROR setControllerDataFromHID(VPADStatus * data){
ControllerPatcher::setControllerDataFromHID(data);
}
extern "C" CONTROLLER_PATCHER_RESULT_OR_ERROR gettingInputAllDevicesEx(InputDataEx * output,s32 array_size){
ControllerPatcher::gettingInputAllDevicesEx(output,array_size);
extern "C" CONTROLLER_PATCHER_RESULT_OR_ERROR gettingInputAllDevices(InputData * output,s32 array_size){
ControllerPatcher::gettingInputAllDevices(output,array_size);
}
extern "C" void ControllerPatcherDeInit(void){

2
ControllerPatcherWrapper.h
View File

@ -14,7 +14,7 @@ extern "C" {
void ControllerPatcherInit(void);
void ControllerPatcherDeInit(void);
CONTROLLER_PATCHER_RESULT_OR_ERROR setControllerDataFromHID(VPADStatus * data);
CONTROLLER_PATCHER_RESULT_OR_ERROR gettingInputAllDevicesEx(InputDataEx * output,s32 array_size);
CONTROLLER_PATCHER_RESULT_OR_ERROR gettingInputAllDevices(InputData * output,s32 array_size);
#ifdef __cplusplus
}

34
patcher/ControllerPatcherDefs.h
View File

@ -223,6 +223,14 @@ typedef struct _HIDSlotData{
u32 hidmask; /**< Used HID-Mask */
}HIDSlotData;
/**
* @brief Stores a VID and PID
*/
typedef struct _DeviceVIDPIDInfo{
u16 vid; /**< Vendor ID of this device */
u16 pid; /**< Product ID of this device */
}DeviceVIDPIDInfo;
/**
* @brief Struct where the data for the callback funtion is stored
*/
@ -235,6 +243,7 @@ typedef struct _my_cb_user{
u8 pad_slot; /**< number of the pad that will be used */
u8 rumblestatus[HID_MAX_PADS_COUNT]; /**< Current status of the device rumble */
u8 forceRumbleInTicks[HID_MAX_PADS_COUNT];
DeviceVIDPIDInfo vidpid; /**< The VID/PID of the device */
}my_cb_user;
/**
@ -289,15 +298,6 @@ typedef struct _HID_DEVICE_DATA {
HID_Data pad_data[HID_MAX_PADS_COUNT];
} HID_DEVICE_DATA;
/**
* @brief Stores a VID and PID
*/
typedef struct _DeviceVIDPIDInfo{
u16 vid; /**< Vendor ID of this device */
u16 pid; /**< Product ID of this device */
}DeviceVIDPIDInfo;
/**
* @brief Infos of the device
*/
@ -353,14 +353,6 @@ typedef struct _InputButtonData{
u32 release; /**< Buttons that were button released */
}InputButtonData;
/**
* @brief Struct where the inputdata of a device for all HID_MAX_PADS_COUNT pads can be stored
*/
typedef struct _InputData{
DeviceInfo device_info; /**< Infos about the device where the data is coming from */
InputButtonData button_data[HID_MAX_PADS_COUNT];
}InputData;
typedef struct _InputStickData{
f32 leftStickX;
f32 leftStickY;
@ -368,11 +360,15 @@ typedef struct _InputStickData{
f32 rightStickY;
}InputStickData;
typedef struct _InputDataEx{
/**
* @brief Struct where the inputdata of a device for all HID_MAX_PADS_COUNT pads can be stored
*/
typedef struct _InputData{
DeviceInfo device_info; /**< Infos about the device where the data is coming from */
u8 status;
InputButtonData button_data;
InputStickData stick_data;
}InputDataEx;
}InputData;
/**
* @brief The enumeration of WiiU Controller types

19
patcher/ControllerPatcherHID.cpp
View File

@ -160,6 +160,7 @@ s32 ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevice *p
usr->slotdata = device_info.slotdata;
usr->transfersize = p_device->max_packet_size_rx;
usr->handle = p_device->handle;
usr->vidpid = device_info.vidpid;
gHIDAttached |= slotdata->hidmask;
gHIDCurrentDevice |= slotdata->hidmask;
s32 pads_per_device = 1;
@ -220,6 +221,15 @@ s32 ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevice *p
DCInvalidateRange(&gHID_Devices[slotdata->deviceslot].pad_data[pad_slot+i],sizeof(HID_Data));
}
for(s32 j = 0;j < pads_per_device; j++){
for(s32 i = 0;i < gHIDMaxDevices; i++){
if(connectionOrderHelper[i] == NULL){
connectionOrderHelper[i] = usr;
break;
}
}
}
if(HID_DEBUG){ printf("ControllerPatcherHID::AttachDetachCallback(line %d): Device successfully attached\n",__LINE__); }
if(slotdata->hidmask == gHID_LIST_GC){ // GC PAD
@ -299,6 +309,15 @@ s32 ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevice *p
}
if(user_data){
for(s32 j = 0;j < user_data->pads_per_device; j++){
for(s32 i = 0;i < gHIDMaxDevices; i++){
if(connectionOrderHelper[i] == user_data){
connectionOrderHelper[i] = NULL;
break;
}
}
}
config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1] &= ~ (1 << user_data->pad_slot);
DCFlushRange(&config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1],sizeof(config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1]));
DCInvalidateRange(&config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1],sizeof(config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1]));

2
utils/CPRetainVars.cpp
View File

@ -64,6 +64,8 @@ u8 gCallbackCooldown __attribute__((section(".data"))) = 0;
u8 gGlobalRumbleActivated __attribute__((section(".data"))) = 0;
my_cb_user * connectionOrderHelper[gHIDMaxDevices] __attribute__((section(".data")));
u32 gUDPClientip __attribute__((section(".data"))) = 0;
ControllerMappingPADInfo* gProPadInfo[4] __attribute__((section(".data"))) = {&gControllerMapping.proController[0].pad_infos[0],
&gControllerMapping.proController[1].pad_infos[0],

2
utils/CPRetainVars.hpp
View File

@ -68,6 +68,8 @@ extern wpad_sampling_callback_t gSamplingCallback;
extern u8 gCallbackCooldown;
extern u8 gGlobalRumbleActivated;
extern my_cb_user * connectionOrderHelper[gHIDMaxDevices];
extern u32 gUDPClientip;
extern ControllerMappingPADInfo* gProPadInfo[4];