static int _ss_change_cb(int result, void *usrdata) {
if (!_ss_rem_cb) {
/* As it's not coming from the removal callback
then we detected a new device being inserted */
_dev_detected = 1;
}
else {
_ss_rem_cb = 0;
}
/* Re-apply the callback notification for future connections changes*/
USB_DeviceChangeNotifyAsync(USB_CLASS_HID, _ss_change_cb, NULL);
return 1;
}
int ss_init(struct ss_device *dev_list, int slots) {
if (!_ss_inited) {
_ss_dev_list = dev_list;
_slots = slots;
int i;
for (i = 0;i < _slots; i++) {
_ss_initialize(&_ss_dev_list[i]);
}
USB_DeviceChangeNotifyAsync(USB_CLASS_HID, _ss_change_cb, NULL);
_dev_detected = 1; /* try open any existing sixasis device */
_ss_inited = 1;
}
return _ss_inited;
}
static void *wiiusb_hid_init(void)
{
unsigned i;
u8 count;
int ret;
usb_device_entry *dev_entries;
wiiusb_hid_t *hid = (wiiusb_hid_t*)calloc(1, sizeof(*hid));
(void)ret;
if (!hid)
goto error;
hid->slots = pad_connection_init(MAX_USERS);
if (!hid->slots)
goto error;
dev_entries = (usb_device_entry *)calloc(MAX_USERS, sizeof(*dev_entries));
if (!dev_entries)
goto error;
USB_Initialize();
if (USB_GetDeviceList(dev_entries, MAX_USERS, USB_CLASS_HID, &count) < 0)
{
free(dev_entries);
goto error;
}
for (i = 0; i < count; i++)
{
if (dev_entries[i].vid > 0 && dev_entries[i].pid > 0)
add_adapter(hid, &dev_entries[i]);
}
free(dev_entries);
USB_DeviceChangeNotifyAsync(USB_CLASS_HID, wiiusb_hid_changenotify_cb, (void *)hid);
return hid;
error:
wiiusb_hid_free(hid);
return NULL;
}
static int wiiusb_hid_change_cb(int result, void *usrdata)
{
wiiusb_hid_t *hid = (wiiusb_hid_t*)usrdata;
if (!hid)
return -1;
/* As it's not coming from the removal callback
then we detected a new device being inserted */
if (!hid->removal_cb)
hid->device_detected = true;
else
hid->removal_cb = false;
/* Re-submit the change alert */
USB_DeviceChangeNotifyAsync(USB_CLASS_HID, wiiusb_hid_change_cb, usrdata);
return 0;
}
static int wiiusb_hid_changenotify_cb(int result, void *usrdata)
{
wiiusb_hid_t *hid = (wiiusb_hid_t*)usrdata;
if (!hid)
return -1;
/* usb_device_entry entries[8];
u8 cnt = 0;
USB_GetDeviceList(entries, 8, USB_CLASS_HID, &cnt);
add_adapter((void *)hid, &entries[0]); */
// RARCH_LOG("Wii USB hid change notify callback\n");
USB_DeviceChangeNotifyAsync(USB_CLASS_HID, wiiusb_hid_changenotify_cb, usrdata);
return 0;
}
static void *wiiusb_hid_init(void)
{
joypad_connection_t *connections = NULL;
wiiusb_hid_t *hid = (wiiusb_hid_t*)calloc(1, sizeof(*hid));
if (!hid)
goto error;
connections = pad_connection_init(MAX_USERS);
if (!connections)
goto error;
/* Initialize HID values */
hid->connections = connections;
hid->adapters_head = NULL;
hid->removal_cb = FALSE;
hid->manual_removal = FALSE;
hid->poll_thread_quit = FALSE;
/* we set it initially to TRUE so we force
* to add the already connected pads */
hid->device_detected = TRUE;
hid->poll_thread = sthread_create(wiiusb_hid_poll_thread, hid);
if (!hid->poll_thread)
{
RARCH_ERR("Error initializing poll thread.\n");
goto error;
}
USB_DeviceChangeNotifyAsync(USB_CLASS_HID, wiiusb_hid_change_cb, (void *)hid);
return hid;
error:
wiiusb_hid_free(hid);
return NULL;
}
static void gx_joypad_poll(void)
{
unsigned i, j, port;
uint8_t gcpad = 0;
global_t *global = global_get_ptr();
pad_state[0] = 0;
pad_state[1] = 0;
pad_state[2] = 0;
pad_state[3] = 0;
gcpad = PAD_ScanPads();
#ifdef HW_RVL
WPAD_ReadPending(WPAD_CHAN_ALL, NULL);
#endif
for (port = 0; port < MAX_PADS; port++)
{
uint32_t down = 0, ptype = WPAD_EXP_NOCONTROLLER;
uint64_t *state_cur = &pad_state[port];
#ifdef HW_RVL
if (WPADProbe(port, &ptype) == WPAD_ERR_NONE)
{
WPADData *wpaddata = (WPADData*)WPAD_Data(port);
expansion_t *exp = NULL;
down = wpaddata->btns_h;
exp = (expansion_t*)&wpaddata->exp;
*state_cur |= (down & WPAD_BUTTON_A) ? (1ULL << GX_WIIMOTE_A) : 0;
*state_cur |= (down & WPAD_BUTTON_B) ? (1ULL << GX_WIIMOTE_B) : 0;
*state_cur |= (down & WPAD_BUTTON_1) ? (1ULL << GX_WIIMOTE_1) : 0;
*state_cur |= (down & WPAD_BUTTON_2) ? (1ULL << GX_WIIMOTE_2) : 0;
*state_cur |= (down & WPAD_BUTTON_PLUS) ? (1ULL << GX_WIIMOTE_PLUS) : 0;
*state_cur |= (down & WPAD_BUTTON_MINUS) ? (1ULL << GX_WIIMOTE_MINUS) : 0;
*state_cur |= (down & WPAD_BUTTON_HOME) ? (1ULL << GX_WIIMOTE_HOME) : 0;
if (ptype != WPAD_EXP_NUNCHUK)
{
/* Rotated d-pad on Wiimote. */
*state_cur |= (down & WPAD_BUTTON_UP) ? (1ULL << GX_WIIMOTE_LEFT) : 0;
*state_cur |= (down & WPAD_BUTTON_DOWN) ? (1ULL << GX_WIIMOTE_RIGHT) : 0;
*state_cur |= (down & WPAD_BUTTON_LEFT) ? (1ULL << GX_WIIMOTE_DOWN) : 0;
*state_cur |= (down & WPAD_BUTTON_RIGHT) ? (1ULL << GX_WIIMOTE_UP) : 0;
}
if (ptype == WPAD_EXP_CLASSIC)
{
*state_cur |= (down & WPAD_CLASSIC_BUTTON_A) ? (1ULL << GX_CLASSIC_A) : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_B) ? (1ULL << GX_CLASSIC_B) : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_X) ? (1ULL << GX_CLASSIC_X) : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_Y) ? (1ULL << GX_CLASSIC_Y) : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_UP) ? (1ULL << GX_CLASSIC_UP) : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_DOWN) ? (1ULL << GX_CLASSIC_DOWN) : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_LEFT) ? (1ULL << GX_CLASSIC_LEFT) : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_RIGHT) ? (1ULL << GX_CLASSIC_RIGHT) : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_PLUS) ? (1ULL << GX_CLASSIC_PLUS) : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_MINUS) ? (1ULL << GX_CLASSIC_MINUS) : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_HOME) ? (1ULL << GX_CLASSIC_HOME) : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_FULL_L) ? (1ULL << GX_CLASSIC_L_TRIGGER) : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_FULL_R) ? (1ULL << GX_CLASSIC_R_TRIGGER) : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_ZL) ? (1ULL << GX_CLASSIC_ZL_TRIGGER) : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_ZR) ? (1ULL << GX_CLASSIC_ZR_TRIGGER) : 0;
analog_state[port][RETRO_DEVICE_INDEX_ANALOG_LEFT][RETRO_DEVICE_ID_ANALOG_X] = WPAD_StickX(wpaddata, port, 0);
analog_state[port][RETRO_DEVICE_INDEX_ANALOG_LEFT][RETRO_DEVICE_ID_ANALOG_Y] = WPAD_StickY(wpaddata, port, 0);
analog_state[port][RETRO_DEVICE_INDEX_ANALOG_RIGHT][RETRO_DEVICE_ID_ANALOG_X] = WPAD_StickX(wpaddata, port, 1);
analog_state[port][RETRO_DEVICE_INDEX_ANALOG_RIGHT][RETRO_DEVICE_ID_ANALOG_Y] = WPAD_StickY(wpaddata, port, 1);
}
else if (ptype == WPAD_EXP_NUNCHUK)
{
/* Wiimote is held upright with nunchuk,
* do not change d-pad orientation. */
*state_cur |= (down & WPAD_BUTTON_UP) ? (1ULL << GX_WIIMOTE_UP) : 0;
*state_cur |= (down & WPAD_BUTTON_DOWN) ? (1ULL << GX_WIIMOTE_DOWN) : 0;
*state_cur |= (down & WPAD_BUTTON_LEFT) ? (1ULL << GX_WIIMOTE_LEFT) : 0;
*state_cur |= (down & WPAD_BUTTON_RIGHT) ? (1ULL << GX_WIIMOTE_RIGHT) : 0;
*state_cur |= (down & WPAD_NUNCHUK_BUTTON_Z) ? (1ULL << GX_NUNCHUK_Z) : 0;
*state_cur |= (down & WPAD_NUNCHUK_BUTTON_C) ? (1ULL << GX_NUNCHUK_C) : 0;
float js_mag = exp->nunchuk.js.mag;
float js_ang = exp->nunchuk.js.ang;
if (js_mag > 1.0f)
js_mag = 1.0f;
else if (js_mag < -1.0f)
js_mag = -1.0f;
double js_val_x = js_mag * sin(M_PI * js_ang / 180.0);
double js_val_y = -js_mag * cos(M_PI * js_ang / 180.0);
int16_t x = (int16_t)(js_val_x * 32767.0f);
int16_t y = (int16_t)(js_val_y * 32767.0f);
analog_state[port][RETRO_DEVICE_INDEX_ANALOG_LEFT][RETRO_DEVICE_ID_ANALOG_X] = x;
analog_state[port][RETRO_DEVICE_INDEX_ANALOG_LEFT][RETRO_DEVICE_ID_ANALOG_Y] = y;
}
}
else
#endif
{
if (gcpad & (1 << port))
{
int16_t ls_x, ls_y, rs_x, rs_y;
uint64_t menu_combo = 0;
down = PAD_ButtonsHeld(port);
*state_cur |= (down & PAD_BUTTON_A) ? (1ULL << GX_GC_A) : 0;
*state_cur |= (down & PAD_BUTTON_B) ? (1ULL << GX_GC_B) : 0;
*state_cur |= (down & PAD_BUTTON_X) ? (1ULL << GX_GC_X) : 0;
*state_cur |= (down & PAD_BUTTON_Y) ? (1ULL << GX_GC_Y) : 0;
*state_cur |= (down & PAD_BUTTON_UP) ? (1ULL << GX_GC_UP) : 0;
*state_cur |= (down & PAD_BUTTON_DOWN) ? (1ULL << GX_GC_DOWN) : 0;
*state_cur |= (down & PAD_BUTTON_LEFT) ? (1ULL << GX_GC_LEFT) : 0;
*state_cur |= (down & PAD_BUTTON_RIGHT) ? (1ULL << GX_GC_RIGHT) : 0;
*state_cur |= (down & PAD_BUTTON_START) ? (1ULL << GX_GC_START) : 0;
*state_cur |= (down & PAD_TRIGGER_Z) ? (1ULL << GX_GC_Z_TRIGGER) : 0;
*state_cur |= ((down & PAD_TRIGGER_L) || PAD_TriggerL(port) > 127) ? (1ULL << GX_GC_L_TRIGGER) : 0;
*state_cur |= ((down & PAD_TRIGGER_R) || PAD_TriggerR(port) > 127) ? (1ULL << GX_GC_R_TRIGGER) : 0;
ls_x = (int16_t)PAD_StickX(port) * 256;
ls_y = (int16_t)PAD_StickY(port) * -256;
rs_x = (int16_t)PAD_SubStickX(port) * 256;
rs_y = (int16_t)PAD_SubStickY(port) * -256;
analog_state[port][RETRO_DEVICE_INDEX_ANALOG_LEFT][RETRO_DEVICE_ID_ANALOG_X] = ls_x;
analog_state[port][RETRO_DEVICE_INDEX_ANALOG_LEFT][RETRO_DEVICE_ID_ANALOG_Y] = ls_y;
analog_state[port][RETRO_DEVICE_INDEX_ANALOG_RIGHT][RETRO_DEVICE_ID_ANALOG_X] = rs_x;
analog_state[port][RETRO_DEVICE_INDEX_ANALOG_RIGHT][RETRO_DEVICE_ID_ANALOG_Y] = rs_y;
menu_combo = (1ULL << GX_GC_START) | (1ULL << GX_GC_Z_TRIGGER) |
(1ULL << GX_GC_L_TRIGGER) | (1ULL << GX_GC_R_TRIGGER);
if ((*state_cur & menu_combo) == menu_combo)
*state_cur |= (1ULL << GX_WIIMOTE_HOME);
ptype = WPAD_EXP_GAMECUBE;
}
#ifdef HAVE_LIBSICKSAXIS
else
{
USB_DeviceChangeNotifyAsync(USB_CLASS_HID, change_cb, (void*)&lol);
if (ss_is_connected(&dev[port]))
{
ptype = WPAD_EXP_SICKSAXIS;
*state_cur |= (dev[port].pad.buttons.PS) ? (1ULL << RARCH_MENU_TOGGLE) : 0;
*state_cur |= (dev[port].pad.buttons.cross) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_B) : 0;
*state_cur |= (dev[port].pad.buttons.square) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_Y) : 0;
*state_cur |= (dev[port].pad.buttons.select) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_SELECT) : 0;
*state_cur |= (dev[port].pad.buttons.start) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_START) : 0;
*state_cur |= (dev[port].pad.buttons.up) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_UP) : 0;
*state_cur |= (dev[port].pad.buttons.down) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_DOWN) : 0;
*state_cur |= (dev[port].pad.buttons.left) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_LEFT) : 0;
*state_cur |= (dev[port].pad.buttons.right) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_RIGHT) : 0;
*state_cur |= (dev[port].pad.buttons.circle) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_A) : 0;
*state_cur |= (dev[port].pad.buttons.triangle) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_X) : 0;
*state_cur |= (dev[port].pad.buttons.L1) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_L) : 0;
*state_cur |= (dev[port].pad.buttons.R1) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_R) : 0;
*state_cur |= (dev[port].pad.buttons.L2) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_L2) : 0;
*state_cur |= (dev[port].pad.buttons.R2) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_R2) : 0;
*state_cur |= (dev[port].pad.buttons.L3) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_L3) : 0;
*state_cur |= (dev[port].pad.buttons.R3) ? (1ULL << RETRO_DEVICE_ID_JOYPAD_R3) : 0;
}
else
{
if (ss_open(&dev[port]) > 0)
{
ptype = WPAD_EXP_SICKSAXIS;
ss_start_reading(&dev[port]);
ss_set_removal_cb(&dev[port], removal_cb, (void*)1);
}
}
}
#endif
}
if (ptype != pad_type[port])
handle_hotplug(port, ptype);
for (i = 0; i < 2; i++)
for (j = 0; j < 2; j++)
if (analog_state[port][i][j] == -0x8000)
analog_state[port][i][j] = -0x7fff;
}
uint64_t *state_p1 = &pad_state[0];
uint64_t *lifecycle_state = &global->lifecycle_state;
*lifecycle_state &= ~((1ULL << RARCH_MENU_TOGGLE));
if (g_menu)
{
*state_p1 |= (1ULL << GX_WIIMOTE_HOME);
g_menu = false;
}
if (*state_p1 & ((1ULL << GX_WIIMOTE_HOME)
#ifdef HW_RVL
| (1ULL << GX_CLASSIC_HOME)
#endif
))
*lifecycle_state |= (1ULL << RARCH_MENU_TOGGLE);
}
int main(int argc, char **argv)
{
SYS_SetResetCallback(WiiResetPressed);
SYS_SetPowerCallback(WiiPowerPressed);
usleep(250*1000);
GRRLIB_Init();
GRRLIB_ttfFont *font = GRRLIB_LoadTTF(verdana_ttf, verdana_ttf_size);
WPAD_Init();
USB_Initialize();
USB_DeviceChangeNotifyAsync(USB_CLASS_HID, change_notify_cb, NULL);
int dev_id = get_device_id();
int fd = open_device(dev_id);
struct ds4_input data;
memset(&data, 0, sizeof(data));
fetch_data(fd, &data);
random_leds(fd);
int screenW = rmode->fbWidth, screenH = rmode->efbHeight;
float pos_x = screenW/2, pos_y = screenH/2;
while (run) {
WPAD_ScanPads();
u32 pressed = WPAD_ButtonsDown(0);
if (pressed & WPAD_BUTTON_B) {
dev_id = get_device_id();
fd = open_device(dev_id);
}
if (pressed & WPAD_BUTTON_A) {
random_leds(fd);
}
GRRLIB_FillScreen(0x0);
GRRLIB_PrintfTTF(15, 15, font, "ds4wii by xerpi | L1: center | R1: random color", 15, 0xFFFFFFFF);
u32 color = (r<<24)|(g<<16)|(b<<8)|0xFF;
GRRLIB_Circle(pos_x, pos_y, 15, color, 0);
GRRLIB_Circle(pos_x, pos_y, 14, color, 0);
memset(&data, 0, sizeof(data));
fetch_data(fd, &data);
if (data.L1) {pos_x = screenW/2, pos_y = screenH/2;}
if (data.R1) {random_leds(fd);}
//1920x940
if (data.finger1active) {
GRRLIB_Circle((screenW/1920.0f)*data.finger1X, (screenH/940.0f)*data.finger1Y, 10, 0x00FF00FF, 1);
}
if (data.finger2active) {
GRRLIB_Circle((screenW/1920.0f)*data.finger2X, (screenH/940.0f)*data.finger2Y, 10, 0x0000FFFF, 1);
}
/*char buf1[256];
sprintf(buf1, "aX: %8hi aY: %8hi aZ: %8hi", data.accelX, data.accelY, data.accelZ);
char buf2[256];
sprintf(buf2, "gyroX: %8hi gyroY: %8hi gyroZ: %8hi", data.gyroX, data.gyroY, data.gyroZ);
GRRLIB_PrintfTTF(15, 30, font, buf1, 14, 0xFFFFFFFF);
GRRLIB_PrintfTTF(15, 45, font, buf2, 14, 0xFFFFFFFF);
*/
#define THRESHOLD 50.0f
if (fabs(data.accelX) > THRESHOLD)
pos_y -= data.accelX/55.0f;
if (fabs(data.accelY) > THRESHOLD)
pos_x -= data.accelY/55.0f;
if (pressed & WPAD_BUTTON_HOME) run = 0;
GRRLIB_Render();
}
USB_CloseDevice(&fd);
USB_Deinitialize();
GRRLIB_FreeTTF (font);
GRRLIB_Exit();
exit(0);
return 0;
}