void grlib_Controllers (bool enable)
{
if (enable)
{
PAD_Init();
WPAD_Init();
WPAD_SetDataFormat(WPAD_CHAN_0, WPAD_FMT_BTNS_ACC_IR);
WPAD_SetVRes(0, 640, 480);
WPAD_SetPowerButtonCallback( wmpower_cb );
}
else
{
u8 i;
for (i = 0; i < WPAD_MAX_WIIMOTES; i++)
{
if(WPAD_Probe(i,0) < 0) continue;
WPAD_Flush(i);
WPAD_Disconnect(i);
}
WPAD_Shutdown();
PAD_Reset(0xf0000000);
}
}
static void wpad_config(u8 num)
{
int i,j;
int max = MAX_KEYS;
u8 quit;
char msg[30];
u32 current = 255;
/* check wiimote status */
if (WPAD_Probe(num, ¤t) != WPAD_ERR_NONE)
{
WaitPrompt("Wiimote is not connected !");
return;
}
/* index for wpad_keymap */
u8 index = current + (num * 3);
/* loop on each mapped keys */
for (i=0; i<max; i++)
{
/* remove any pending buttons */
while (WPAD_ButtonsHeld(num))
{
WPAD_ScanPads();
VIDEO_WaitVSync();
}
/* user information */
ClearScreen();
sprintf(msg,"Press key for %s",keys_name[i]);
WriteCentre(254, msg);
SetScreen();
/* wait for input */
quit = 0;
while (quit == 0)
{
WPAD_ScanPads();
/* get buttons */
for (j=0; j<20; j++)
{
if (WPAD_ButtonsDown(num) & wpad_keys[j])
{
wpad_keymap[index][i] = wpad_keys[j];
quit = 1;
j = 20; /* leave loop */
}
}
} /* wait for input */
} /* loop for all keys */
/* removed any pending buttons */
while (WPAD_ButtonsHeld(num))
{
WPAD_ScanPads();
VIDEO_WaitVSync();
}
}
u32 InputDevices::GetPadButtonStatus(int channel)
{
u32 extensions;
WPADData data;
u32 buttons, gcbuttons;
PAD2WPAD *p2w;
joystick_t padjoy;
// Check standard buttons
buttons = WPAD_ButtonsHeld(channel);
// Add GameCube buttons
gcbuttons = PAD_ButtonsHeld(channel);
p2w = pad2wpad;
while( p2w->pad ) {
if( gcbuttons & p2w->pad ) {
buttons |= p2w->wpad;
}
p2w++;
}
// Key translations for default WiiMote buttons
ProcessWPadButtons(channel, wpad_default);
// Check extensions
WPAD_Probe(channel, &extensions);
if( extensions == WPAD_EXP_NUNCHUK ) {
// Nunchuk stick
WPAD_Expansion(channel, &data.exp);
buttons |= GetJoystickDirection(&data.exp.nunchuk.js);
// Nunchuck key translations
ProcessWPadButtons(channel, wpad_nunchuk);
} else if( extensions == WPAD_EXP_CLASSIC ) {
// Both classic controller sticks
WPAD_Expansion(channel, &data.exp);
buttons |= GetJoystickDirection(&data.exp.classic.ljs);
buttons |= GetJoystickDirection(&data.exp.classic.rjs);
// Classic controller key translations
ProcessWPadButtons(channel, wpad_classic);
}
// Scan GameCube sticks
padjoy.min.x = 0;
padjoy.min.y = 0;
padjoy.max.x = 255;
padjoy.max.y = 255;
padjoy.center.x = 128;
padjoy.center.y = 128;
padjoy.pos.x = (int)PAD_StickX(channel) + 128;
padjoy.pos.y = (int)PAD_StickY(channel) + 128;
buttons |= GetJoystickDirection(&padjoy);
padjoy.pos.x = (int)PAD_SubStickX(channel) + 128;
padjoy.pos.y = (int)PAD_SubStickY(channel) + 128;
buttons |= GetJoystickDirection(&padjoy);
return buttons;
}
static void show_console(int code) {
u32 i, b;
printf("ScummVM exited abnormally (%d).\n", code);
gfx_frame_abort();
gfx_init();
if (!gfx_frame_start())
return;
gfx_con_draw();
gfx_frame_end();
for (i = 0; i < 60 * 3; ++i)
VIDEO_WaitVSync();
#ifdef DEBUG_WII_GDB
printf("attach gdb now\n");
_break();
#endif
printf("Press any key to continue.\n");
if (!gfx_frame_start())
return;
gfx_con_draw();
gfx_frame_end();
VIDEO_WaitVSync();
while (true) {
b = 0;
if (PAD_ScanPads() & 1)
b = PAD_ButtonsDown(0);
#ifndef GAMECUBE
WPAD_ScanPads();
if (WPAD_Probe(0, NULL) == WPAD_ERR_NONE)
b |= WPAD_ButtonsDown(0);
#endif
if (b)
break;
VIDEO_WaitVSync();
}
printf("\n\nExiting...\n");
if (!gfx_frame_start())
return;
gfx_con_draw();
gfx_frame_end();
VIDEO_WaitVSync();
}
u32 GetCtlType(int ctl) {
struct expansion_t ext;
u32 devtype;
u32 ret;
u32 type;
ret=WPAD_Probe(WPAD_CHAN_0, &type);
WPAD_Expansion(ctl, &ext);
devtype=ext.type;
if (devtype == WPAD_EXP_NONE) return 0;
if (devtype == WPAD_EXP_NUNCHUK) {printf("\x1b[20;0HNunchuk X: %d\n Nunchuk Y: %d\n", ext.nunchuk.js.pos.x, ext.nunchuk.js.pos.y); return 1;}
if (devtype == WPAD_EXP_CLASSIC) return 2;
return devtype;
}
int main(int argc, char **argv) {
void *xfb[2];
u32 type;
int fbi = 0;
VIDEO_Init();
PAD_Init();
WPAD_Init();
rmode = VIDEO_GetPreferredMode(NULL);
// double buffering, prevents flickering (is it needed for LCD TV? i don't have one to test)
xfb[0] = MEM_K0_TO_K1(SYS_AllocateFramebuffer(rmode));
xfb[1] = MEM_K0_TO_K1(SYS_AllocateFramebuffer(rmode));
VIDEO_Configure(rmode);
VIDEO_SetNextFramebuffer(xfb);
VIDEO_SetBlack(FALSE);
VIDEO_Flush();
VIDEO_WaitVSync();
if(rmode->viTVMode&VI_NON_INTERLACE) VIDEO_WaitVSync();
SYS_SetResetCallback(reload);
SYS_SetPowerCallback(shutdown);
WPAD_SetDataFormat(0, WPAD_FMT_BTNS_ACC_IR);
WPAD_SetVRes(0, rmode->fbWidth, rmode->xfbHeight);
while(!doreload && !dooff) {
CON_Init(xfb[fbi],0,0,rmode->fbWidth,rmode->xfbHeight,rmode->fbWidth*VI_DISPLAY_PIX_SZ);
//VIDEO_ClearFrameBuffer(rmode,xfb[fbi],COLOR_BLACK);
std::cout<<"\n\n\n";
WPAD_ReadPending(WPAD_CHAN_ALL, countevs);
int wiimote_connection_status = WPAD_Probe(0, &type);
print_wiimote_connection_status(wiimote_connection_status);
std::cout<<" Event count: "<<evctr<<"\n";
if(wiimote_connection_status == WPAD_ERR_NONE) {
print_and_draw_wiimote_data(xfb[fbi]);
}
VIDEO_SetNextFramebuffer(xfb[fbi]);
VIDEO_Flush();
VIDEO_WaitVSync();
fbi ^= 1;
}
if(doreload) return 0;
if(dooff) SYS_ResetSystem(SYS_SHUTDOWN,0,0);
return 0;
}
static void refreshAvailable(void){
int i;
u32 expType;
WPAD_ScanPads();
for(i=0; i<4; ++i){
int err = WPAD_Probe(i, &expType);
if(err == WPAD_ERR_NONE &&
expType == WPAD_EXP_CLASSIC){
controller_Classic.available[i] = 1;
WPAD_SetDataFormat(i, WPAD_DATA_EXPANSION);
} else
controller_Classic.available[i] = 0;
}
}
bool IsWpadConnected()
{
int i = 0;
u32 test = 0;
int notconnected = 0;
for (i = 0; i < 4; i++)
{
if (WPAD_Probe(i, &test) == WPAD_ERR_NO_CONTROLLER)
{
notconnected++;
}
}
if (notconnected < 4)
return true;
else return false;
}
static int available(int Control) {
int err;
u32 expType;
err = WPAD_Probe(Control, &expType);
if(err == WPAD_ERR_NONE &&
expType == WPAD_EXP_CLASSIC){
controller_Classic.available[Control] = 1;
return 1;
} else {
controller_Classic.available[Control] = 0;
if(err == WPAD_ERR_NONE &&
expType == WPAD_EXP_NUNCHUK){
controller_WiimoteNunchuk.available[Control] = 1;
}
else if (err == WPAD_ERR_NONE &&
expType == WPAD_EXP_NONE){
controller_Wiimote.available[Control] = 1;
}
return 0;
}
}
u32 StandardDPad(unsigned short pad)
{
u32 J = 0;
u32 jp = PAD_ButtonsHeld(pad);
#ifdef HW_RVL
u32 exp_type;
if ( WPAD_Probe(pad, &exp_type) != 0 )
exp_type = WPAD_EXP_NONE;
u32 wp = WPAD_ButtonsHeld(pad);
if (wp & WPAD_BUTTON_RIGHT)
J |= VBA_RIGHT;
if (wp & WPAD_BUTTON_LEFT)
J |= VBA_LEFT;
if (wp & WPAD_BUTTON_UP)
J |= VBA_UP;
if (wp & WPAD_BUTTON_DOWN)
J |= VBA_DOWN;
if (exp_type == WPAD_EXP_CLASSIC)
{
if (wp & WPAD_CLASSIC_BUTTON_UP)
J |= VBA_UP;
if (wp & WPAD_CLASSIC_BUTTON_DOWN)
J |= VBA_DOWN;
if (wp & WPAD_CLASSIC_BUTTON_LEFT)
J |= VBA_LEFT;
if (wp & WPAD_CLASSIC_BUTTON_RIGHT)
J |= VBA_RIGHT;
}
#endif
if (jp & PAD_BUTTON_UP)
J |= VBA_UP;
if (jp & PAD_BUTTON_DOWN)
J |= VBA_DOWN;
if (jp & PAD_BUTTON_LEFT)
J |= VBA_LEFT;
if (jp & PAD_BUTTON_RIGHT)
J |= VBA_RIGHT;
return J;
}
static void wpad_config(u8 num, u8 exp, u8 padtype)
{
int i,j,max;
u8 quit;
char msg[30];
u32 current = 255;
/* check wiimote status */
WPAD_Probe(num, ¤t);
if (((exp > WPAD_EXP_NONE) && (current != exp)) || (current == 255))
{
if (exp == WPAD_EXP_NONE) sprintf(msg, "WIIMOTE #%d is not connected !", num+1);
if (exp == WPAD_EXP_NUNCHUK) sprintf(msg, "NUNCHUK #%d is not connected !", num+1);
if (exp == WPAD_EXP_CLASSIC) sprintf(msg, "CLASSIC #%d is not connected !", num+1);
WaitPrompt(msg);
return;
}
/* index for wpad_keymap */
u8 index = exp + (num * 3);
/* loop on each mapped keys */
max = (padtype == DEVICE_6BUTTON) ? MAX_KEYS : (MAX_KEYS - 3);
for (i=0; i<max; i++)
{
/* remove any pending buttons */
while (WPAD_ButtonsHeld(num))
{
WPAD_ScanPads();
VIDEO_WaitVSync();
}
/* user information */
ClearScreen();
sprintf(msg,"Press key for %s",keys_name[i]);
WriteCentre(254, msg);
SetScreen();
/* wait for input */
quit = 0;
while (quit == 0)
{
WPAD_ScanPads();
/* get buttons */
for (j=0; j<20; j++)
{
if (WPAD_ButtonsDown(num) & wpad_keys[j])
{
config.wpad_keymap[index][i] = wpad_keys[j];
quit = 1;
j = 20; /* leave loop */
}
}
} /* wait for input */
} /* loop for all keys */
/* removed any pending buttons */
while (WPAD_ButtonsHeld(num))
{
WPAD_ScanPads();
VIDEO_WaitVSync();
}
}
static void wpad_update(void)
{
int i,use_wpad;
u32 exp;
u32 p;
s8 x,y;
struct ir_t ir;
/* update WPAD data */
WPAD_ScanPads();
for (i=0; i<2; i++)
{
/* check WPAD status */
if ((WPAD_Probe(i, &exp) == WPAD_ERR_NONE))
{
p = WPAD_ButtonsHeld(i);
x = WPAD_StickX(i, 0);
y = WPAD_StickY(i, 0);
if ((i == 0) && (exp == WPAD_EXP_CLASSIC)) use_wpad = 1;
else use_wpad = 0;
/* retrieve current key mapping */
u8 index = exp + (3 * i);
/* MENU */
if ((p & wpad_keymap[index][KEY_MENU]) || (p & WPAD_BUTTON_HOME))
{
ConfigRequested = 1;
return;
}
/* PAUSE & START */
if (p & wpad_keymap[index][KEY_PAUSE])
input.system |= (sms.console == CONSOLE_GG) ? INPUT_START : INPUT_PAUSE;
/* RESET */
if (((p & WPAD_CLASSIC_BUTTON_PLUS) && (p & WPAD_CLASSIC_BUTTON_MINUS)) ||
((p & WPAD_BUTTON_PLUS) && (p & WPAD_BUTTON_MINUS)) || softreset)
{
input.system |= INPUT_RESET;
softreset = 0;
SYS_SetResetCallback(set_softreset);
}
/* BUTTON 1 */
if (p & wpad_keymap[index][KEY_BUTTON1])
input.pad[i] |= INPUT_BUTTON1;
if (use_wpad && (p & wpad_keymap[0][KEY_BUTTON1]))
input.pad[1] |= INPUT_BUTTON1;
/* BUTTON 2 */
if (p & wpad_keymap[index][KEY_BUTTON2])
input.pad[i] |= INPUT_BUTTON2;
if (use_wpad && (p & wpad_keymap[0][KEY_BUTTON2]))
input.pad[1] |= INPUT_BUTTON2;
/* check emulated device type */
switch (sms.device[i])
{
/* digital gamepad */
case DEVICE_PAD2B:
/* directional buttons */
if ((p & wpad_dirmap[exp][PAD_UP]) || (y > 70)) input.pad[i] |= INPUT_UP;
else if ((p & wpad_dirmap[exp][PAD_DOWN]) || (y < -70)) input.pad[i] |= INPUT_DOWN;
if ((p & wpad_dirmap[exp][PAD_LEFT]) || (x < -60)) input.pad[i] |= INPUT_LEFT;
else if ((p & wpad_dirmap[exp][PAD_RIGHT]) || (x > 60)) input.pad[i] |= INPUT_RIGHT;
if (use_wpad)
{
if ((p & wpad_dirmap[0][PAD_UP]) || (y > 70)) input.pad[1] |= INPUT_UP;
else if ((p & wpad_dirmap[0][PAD_DOWN]) || (y < -70)) input.pad[1] |= INPUT_DOWN;
if ((p & wpad_dirmap[0][PAD_LEFT]) || (x < -60)) input.pad[1] |= INPUT_LEFT;
else if ((p & wpad_dirmap[0][PAD_RIGHT]) || (x > 60)) input.pad[1] |= INPUT_RIGHT;
}
break;
/* analog devices */
case DEVICE_LIGHTGUN:
case DEVICE_SPORTSPAD:
case DEVICE_PADDLE:
/* X position */
if (p & wpad_dirmap[exp][PAD_LEFT]) input.analog[i][0] --;
else if (p & wpad_dirmap[exp][PAD_RIGHT]) input.analog[i][0] ++;
else if (x) input.analog[i][0] = (u8)(x + 128);
/* Y position */
if (p & wpad_dirmap[exp][PAD_UP]) input.analog[i][1] --;
else if (p & wpad_dirmap[exp][PAD_DOWN]) input.analog[i][1] ++;
else if (y) input.analog[i][1] = (u8)(128 - y);
/* by default, use IR pointing */
WPAD_IR(i, &ir);
if (ir.valid)
{
input.analog[i][0] = (ir.x * 4) / 10;
input.analog[i][1] = ir.y / 2;
if (p & WPAD_BUTTON_A) input.pad[i] |= INPUT_BUTTON1;
}
/* limiter */
if (input.analog[i][0] < 0) input.analog[i][0] = 0;
else if (input.analog[i][0] > 0xFF) input.analog[i][0] = 0xFF;
if (input.analog[i][1] < 0) input.analog[i][1] = 0;
else if (input.analog[i][1] > 0xFF) input.analog[i][1] = 0xFF;
break;
/* none */
default:
break;
}
/* Colecovision keypad support */
if (sms.console == CONSOLE_COLECO)
{
u32 pad;
u32 d = WPAD_ButtonsDown(i);
input.system = 0;
if (d & WPAD_CLASSIC_BUTTON_PLUS)
{
pad = (coleco.keypad[i] & 0x0f) + 1;
if (pad > 11) pad = 0;
if (pad == 11)
sprintf(osd.msg,"KeyPad(%d) #",i+1);
else if (pad == 10)
sprintf(osd.msg,"KeyPad(%d) *",i+1);
else sprintf(osd.msg,"KeyPad(%d) %d",i+1,pad);
osd.frames = 60;
coleco.keypad[i] = (coleco.keypad[i] & 0xf0) | pad;
}
if (p & WPAD_CLASSIC_BUTTON_MINUS)
coleco.keypad[i] &= 0x0f;
if (use_wpad)
{
if (d & WPAD_BUTTON_PLUS)
{
pad = (coleco.keypad[1] & 0x0f) + 1;
if (pad > 11) pad = 0;
if (pad == 11)
sprintf(osd.msg,"KeyPad(2) #");
else if (pad == 10)
sprintf(osd.msg,"KeyPad(2) *");
else
sprintf(osd.msg,"KeyPad(2) %d",pad);
osd.frames = 60;
coleco.keypad[1] = (coleco.keypad[1] & 0xf0) | pad;
}
if (p & WPAD_BUTTON_MINUS)
coleco.keypad[1] &= 0x0f;
}
else
{
if (d & WPAD_BUTTON_PLUS)
{
pad = (coleco.keypad[i] & 0x0f) + 1;
if (pad > 11) pad = 0;
if (pad == 11)
sprintf(osd.msg,"KeyPad(%d) #",i+1);
else if (pad == 10)
sprintf(osd.msg,"KeyPad(%d) *",i+1);
else sprintf(osd.msg,"KeyPad(%d) %d",i+1,pad);
osd.frames = 30;
coleco.keypad[i] = (coleco.keypad[i] & 0xf0) | pad;
}
if (p & WPAD_BUTTON_MINUS)
coleco.keypad[i] &= 0x0f;
}
}
}
}
}
static void gx_input_poll(void *data)
{
(void)data;
pad_state[0] = 0;
pad_state[1] = 0;
pad_state[2] = 0;
pad_state[3] = 0;
PAD_ScanPads();
#ifdef HW_RVL
WPAD_ReadPending(WPAD_CHAN_ALL, NULL);
#endif
for (unsigned port = 0; port < MAX_PADS; port++)
{
uint32_t down = 0;
uint64_t *state_cur = &pad_state[port];
bool dpad_emulation = (g_settings.input.dpad_emulation[port] != ANALOG_DPAD_NONE);
#ifdef HW_RVL
uint32_t type = 0;
if (WPAD_Probe(port, &type) == WPAD_ERR_NONE)
{
WPADData *wpaddata = WPAD_Data(port);
down = wpaddata->btns_h;
*state_cur |= (down & WPAD_BUTTON_A) ? GX_WIIMOTE_A : 0;
*state_cur |= (down & WPAD_BUTTON_B) ? GX_WIIMOTE_B : 0;
*state_cur |= (down & WPAD_BUTTON_1) ? GX_WIIMOTE_1 : 0;
*state_cur |= (down & WPAD_BUTTON_2) ? GX_WIIMOTE_2 : 0;
*state_cur |= (down & WPAD_BUTTON_PLUS) ? GX_WIIMOTE_PLUS : 0;
*state_cur |= (down & WPAD_BUTTON_MINUS) ? GX_WIIMOTE_MINUS : 0;
*state_cur |= (down & WPAD_BUTTON_HOME) ? GX_WIIMOTE_HOME : 0;
// rotated d-pad on Wiimote
*state_cur |= (down & WPAD_BUTTON_UP) ? GX_WIIMOTE_LEFT : 0;
*state_cur |= (down & WPAD_BUTTON_DOWN) ? GX_WIIMOTE_RIGHT : 0;
*state_cur |= (down & WPAD_BUTTON_LEFT) ? GX_WIIMOTE_DOWN : 0;
*state_cur |= (down & WPAD_BUTTON_RIGHT) ? GX_WIIMOTE_UP : 0;
expansion_t *exp = &wpaddata->exp;
if (type == WPAD_EXP_CLASSIC)
{
*state_cur |= (down & WPAD_CLASSIC_BUTTON_A) ? GX_CLASSIC_A : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_B) ? GX_CLASSIC_B : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_X) ? GX_CLASSIC_X : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_Y) ? GX_CLASSIC_Y : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_UP) ? GX_CLASSIC_UP : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_DOWN) ? GX_CLASSIC_DOWN : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_LEFT) ? GX_CLASSIC_LEFT : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_RIGHT) ? GX_CLASSIC_RIGHT : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_PLUS) ? GX_CLASSIC_PLUS : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_MINUS) ? GX_CLASSIC_MINUS : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_HOME) ? GX_CLASSIC_HOME : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_FULL_L) ? GX_CLASSIC_L_TRIGGER : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_FULL_R) ? GX_CLASSIC_R_TRIGGER : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_ZL) ? GX_CLASSIC_ZL_TRIGGER : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_ZR) ? GX_CLASSIC_ZR_TRIGGER : 0;
if (dpad_emulation)
{
float ljs_mag = exp->classic.ljs.mag;
float ljs_ang = exp->classic.ljs.ang;
float rjs_mag = exp->classic.rjs.mag;
float rjs_ang = exp->classic.rjs.ang;
if (ljs_mag > 1.0f)
ljs_mag = 1.0f;
else if (ljs_mag < -1.0f)
ljs_mag = -1.0f;
if (rjs_mag > 1.0f)
rjs_mag = 1.0f;
else if (rjs_mag < -1.0f)
rjs_mag = -1.0f;
double ljs_val_x = -ljs_mag * sin(M_PI * ljs_ang / 180.0);
double ljs_val_y = -ljs_mag * cos(M_PI * ljs_ang / 180.0);
double rjs_val_x = -rjs_mag * sin(M_PI * rjs_ang / 180.0);
double rjs_val_y = -rjs_mag * cos(M_PI * rjs_ang / 180.0);
s8 ls_x = (s8)(ljs_val_x * 127.0f);
s8 ls_y = (s8)(ljs_val_y * 127.0f);
s8 rs_x = (s8)(rjs_val_x * 127.0f);
s8 rs_y = (s8)(rjs_val_y * 127.0f);
*state_cur |= (ls_x < -WII_JOYSTICK_THRESHOLD) ? GX_CLASSIC_LSTICK_RIGHT : 0;
*state_cur |= (ls_x > WII_JOYSTICK_THRESHOLD) ? GX_CLASSIC_LSTICK_LEFT : 0;
*state_cur |= (ls_y < -WII_JOYSTICK_THRESHOLD) ? GX_CLASSIC_LSTICK_UP : 0;
*state_cur |= (ls_y > WII_JOYSTICK_THRESHOLD) ? GX_CLASSIC_LSTICK_DOWN : 0;
*state_cur |= (rs_x < -WII_JOYSTICK_THRESHOLD) ? GX_CLASSIC_RSTICK_RIGHT : 0;
*state_cur |= (rs_x > WII_JOYSTICK_THRESHOLD) ? GX_CLASSIC_RSTICK_LEFT: 0;
*state_cur |= (rs_y < -WII_JOYSTICK_THRESHOLD) ? GX_CLASSIC_RSTICK_UP : 0;
*state_cur |= (rs_y > WII_JOYSTICK_THRESHOLD) ? GX_CLASSIC_RSTICK_DOWN : 0;
}
}
else if (type == WPAD_EXP_NUNCHUK)
{
// wiimote is held upright with nunchuk, do not change d-pad orientation
*state_cur |= (down & WPAD_BUTTON_UP) ? GX_WIIMOTE_UP : 0;
*state_cur |= (down & WPAD_BUTTON_DOWN) ? GX_WIIMOTE_DOWN : 0;
*state_cur |= (down & WPAD_BUTTON_LEFT) ? GX_WIIMOTE_LEFT : 0;
*state_cur |= (down & WPAD_BUTTON_RIGHT) ? GX_WIIMOTE_RIGHT : 0;
*state_cur |= (down & WPAD_NUNCHUK_BUTTON_Z) ? GX_NUNCHUK_Z : 0;
*state_cur |= (down & WPAD_NUNCHUK_BUTTON_C) ? GX_NUNCHUK_C : 0;
if (dpad_emulation)
{
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);
s8 x = (s8)(js_val_x * 127.0f);
s8 y = (s8)(js_val_y * 127.0f);
*state_cur |= (x < -WII_JOYSTICK_THRESHOLD) ? GX_NUNCHUK_RIGHT : 0;
*state_cur |= (x > WII_JOYSTICK_THRESHOLD) ? GX_NUNCHUK_LEFT : 0;
*state_cur |= (y < -WII_JOYSTICK_THRESHOLD) ? GX_NUNCHUK_UP : 0;
*state_cur |= (y > WII_JOYSTICK_THRESHOLD) ? GX_NUNCHUK_DOWN : 0;
}
}
}
#endif
if (SI_GetType(port) & SI_TYPE_GC)
{
down = PAD_ButtonsHeld(port);
*state_cur |= (down & PAD_BUTTON_A) ? GX_GC_A : 0;
*state_cur |= (down & PAD_BUTTON_B) ? GX_GC_B : 0;
*state_cur |= (down & PAD_BUTTON_X) ? GX_GC_X : 0;
*state_cur |= (down & PAD_BUTTON_Y) ? GX_GC_Y : 0;
*state_cur |= (down & PAD_BUTTON_UP) ? GX_GC_UP : 0;
*state_cur |= (down & PAD_BUTTON_DOWN) ? GX_GC_DOWN : 0;
*state_cur |= (down & PAD_BUTTON_LEFT) ? GX_GC_LEFT : 0;
*state_cur |= (down & PAD_BUTTON_RIGHT) ? GX_GC_RIGHT : 0;
*state_cur |= (down & PAD_BUTTON_START) ? GX_GC_START : 0;
*state_cur |= (down & PAD_TRIGGER_Z) ? GX_GC_Z_TRIGGER : 0;
*state_cur |= ((down & PAD_TRIGGER_L) || PAD_TriggerL(port) > 127) ? GX_GC_L_TRIGGER : 0;
*state_cur |= ((down & PAD_TRIGGER_R) || PAD_TriggerR(port) > 127) ? GX_GC_R_TRIGGER : 0;
if (dpad_emulation)
{
s8 x = PAD_StickX(port);
s8 y = PAD_StickY(port);
*state_cur |= (x < -GC_JOYSTICK_THRESHOLD) ? GX_GC_LSTICK_LEFT : 0;
*state_cur |= (x > GC_JOYSTICK_THRESHOLD) ? GX_GC_LSTICK_RIGHT : 0;
*state_cur |= (y < -GC_JOYSTICK_THRESHOLD) ? GX_GC_LSTICK_DOWN : 0;
*state_cur |= (y > GC_JOYSTICK_THRESHOLD) ? GX_GC_LSTICK_UP : 0;
x = PAD_SubStickX(port);
y = PAD_SubStickY(port);
*state_cur |= (x < -GC_JOYSTICK_THRESHOLD) ? GX_GC_RSTICK_LEFT : 0;
*state_cur |= (x > GC_JOYSTICK_THRESHOLD) ? GX_GC_RSTICK_RIGHT : 0;
*state_cur |= (y < -GC_JOYSTICK_THRESHOLD) ? GX_GC_RSTICK_DOWN : 0;
*state_cur |= (y > GC_JOYSTICK_THRESHOLD) ? GX_GC_RSTICK_UP : 0;
}
if ((*state_cur & (GX_GC_LSTICK_UP | GX_GC_RSTICK_UP | GX_GC_L_TRIGGER | GX_GC_R_TRIGGER)) == (GX_GC_LSTICK_UP | GX_GC_RSTICK_UP | GX_GC_L_TRIGGER | GX_GC_R_TRIGGER))
*state_cur |= GX_WIIMOTE_HOME;
}
}
uint64_t *state_p1 = &pad_state[0];
uint64_t *lifecycle_state = &g_extern.lifecycle_state;
bool dpad_emulation = (g_settings.input.dpad_emulation[0] != ANALOG_DPAD_NONE);
*lifecycle_state &= ~(
(1ULL << RARCH_FAST_FORWARD_HOLD_KEY) |
(1ULL << RARCH_LOAD_STATE_KEY) |
(1ULL << RARCH_SAVE_STATE_KEY) |
(1ULL << RARCH_STATE_SLOT_PLUS) |
(1ULL << RARCH_STATE_SLOT_MINUS) |
(1ULL << RARCH_REWIND) |
(1ULL << RARCH_QUIT_KEY) |
(1ULL << RARCH_MENU_TOGGLE));
if (dpad_emulation)
{
if (
#ifdef HW_RVL
((*state_p1 & GX_CLASSIC_RSTICK_DOWN) && !(*state_p1 & GX_CLASSIC_ZR_TRIGGER)) ||
#endif
((*state_p1 & GX_GC_RSTICK_DOWN) && !(*state_p1 & GX_GC_Z_TRIGGER))
)
*lifecycle_state |= (1ULL << RARCH_FAST_FORWARD_HOLD_KEY);
if (
#ifdef HW_RVL
((*state_p1 & GX_CLASSIC_RSTICK_UP) && (*state_p1 & GX_CLASSIC_ZR_TRIGGER)) ||
#endif
((*state_p1 & GX_GC_RSTICK_UP) && (*state_p1 & GX_GC_Z_TRIGGER))
)
*lifecycle_state |= (1ULL << RARCH_LOAD_STATE_KEY);
if (
#ifdef HW_RVL
((*state_p1 & GX_CLASSIC_RSTICK_DOWN) && (*state_p1 & GX_CLASSIC_ZR_TRIGGER)) ||
#endif
((*state_p1 & GX_GC_RSTICK_DOWN) && (*state_p1 & GX_GC_Z_TRIGGER))
)
*lifecycle_state |= (1ULL << RARCH_SAVE_STATE_KEY);
if (
#ifdef HW_RVL
((*state_p1 & GX_CLASSIC_RSTICK_RIGHT) && (*state_p1 & GX_CLASSIC_ZR_TRIGGER)) ||
#endif
((*state_p1 & GX_GC_RSTICK_RIGHT) && (*state_p1 & GX_GC_Z_TRIGGER))
)
*lifecycle_state |= (1ULL << RARCH_STATE_SLOT_PLUS);
if (
#ifdef HW_RVL
((*state_p1 & GX_CLASSIC_RSTICK_LEFT) && (*state_p1 & GX_CLASSIC_ZR_TRIGGER)) ||
#endif
((*state_p1 & GX_GC_RSTICK_LEFT) && (*state_p1 & GX_GC_Z_TRIGGER))
)
*lifecycle_state |= (1ULL << RARCH_STATE_SLOT_MINUS);
if (
#ifdef HW_RVL
((*state_p1 & GX_CLASSIC_RSTICK_UP) && !(*state_p1 & GX_CLASSIC_ZR_TRIGGER)) ||
#endif
((*state_p1 & GX_GC_RSTICK_UP) && !(*state_p1 & GX_GC_Z_TRIGGER))
)
*lifecycle_state |= (1ULL << RARCH_REWIND);
}
if (g_menu)
{
*state_p1 |= GX_WIIMOTE_HOME;
g_menu = false;
}
if (*state_p1 & (GX_WIIMOTE_HOME
#ifdef HW_RVL
| GX_CLASSIC_HOME
#endif
))
*lifecycle_state |= (1ULL << RARCH_MENU_TOGGLE);
}
static void poll_input(void)
{
static Sint32 old_x = 1000, old_y = 1000;
static Uint32 old_point = 0;
static Uint32 old_btns[4] = {0};
static Sint16 old_axes[4][4] = {{0}};
static int old_type[4] =
{
WPAD_EXP_NONE, WPAD_EXP_NONE,
WPAD_EXP_NONE, WPAD_EXP_NONE
};
static Uint32 old_gcbtns[4] = {0};
static Sint8 old_gcaxes[4][4] = {{0}};
static Uint16 old_modifiers = 0;
static Uint8 old_mousebtns = 0;
WPADData *wd;
PADStatus pad[4];
keyboard_event ke;
mouse_event me;
u32 type;
union event ev;
Uint32 i, j;
WPAD_ScanPads();
for(i = 0; i < 4; i++)
{
if(WPAD_Probe(i, &type) == WPAD_ERR_NONE)
{
wd = WPAD_Data(i);
if((int)type != old_type[i])
{
scan_buttons(i, old_btns[i], 0);
old_btns[i] = 0;
ev.type = EVENT_AXIS_MOVE;
ev.axis.pad = i;
ev.axis.pos = 0;
for(j = 0; j < 4; j++)
{
if(old_axes[i][j])
{
ev.axis.axis = j;
write_eq(&ev);
old_axes[i][j] = 0;
}
}
ev.type = EVENT_CHANGE_EXT;
ev.ext.pad = i;
old_type[i] = ev.ext.ext = type;
write_eq(&ev);
}
if(i == 0)
{
if(wd->ir.valid)
{
ev.pointer.x = wd->ir.x - PTR_BORDER_W;
ev.pointer.y = wd->ir.y - PTR_BORDER_H;
if (ev.pointer.x < 0)
ev.pointer.x = 0;
if (ev.pointer.y < 0)
ev.pointer.y = 0;
if (ev.pointer.x >= 640)
ev.pointer.x = 639;
if (ev.pointer.y >= 350)
ev.pointer.y = 349;
if ((ev.pointer.x != old_x) || (ev.pointer.y != old_y))
{
ev.type = EVENT_POINTER_MOVE;
write_eq(&ev);
old_point = 1;
old_x = ev.pointer.x;
old_y = ev.pointer.y;
}
}
else
{
if(old_point)
{
ev.type = EVENT_POINTER_OUT;
write_eq(&ev);
old_point = 0;
old_x = old_y = 1000;
}
}
}
scan_buttons(i, old_btns[i], wd->btns_h);
old_btns[i] = wd->btns_h;
switch(type)
{
case WPAD_EXP_NUNCHUK:
{
scan_joystick(i, 0, wd->exp.nunchuk.js, old_axes[i]);
break;
}
case WPAD_EXP_CLASSIC:
{
scan_joystick(i, 0, wd->exp.classic.ljs, old_axes[i]);
scan_joystick(i, 2, wd->exp.classic.rjs, old_axes[i] + 2);
break;
}
case WPAD_EXP_GUITARHERO3:
{
scan_joystick(i, 0, wd->exp.gh3.js, old_axes[i]);
j = (int)(wd->exp.gh3.whammy_bar * 32767.0);
if((int)j != old_axes[i][2])
{
ev.type = EVENT_AXIS_MOVE;
ev.axis.pad = i;
ev.axis.pos = j;
write_eq(&ev);
}
break;
}
default: break;
}
}
else
{
scan_buttons(i, old_btns[i], 0);
old_btns[i] = 0;
ev.type = EVENT_AXIS_MOVE;
ev.axis.pad = i;
ev.axis.pos = 0;
for(j = 0; j < 4; j++)
{
if(old_axes[i][j])
{
ev.axis.axis = j;
write_eq(&ev);
old_axes[i][j] = 0;
}
}
}
}
PAD_Read(pad);
for(i = 0; i < 4; i++)
{
if(pad[i].err == PAD_ERR_NONE)
{
scan_buttons(i + 4, old_gcbtns[i], pad[i].button);
old_gcbtns[i] = pad[i].button;
ev.type = EVENT_AXIS_MOVE;
ev.axis.pad = i + 4;
if(pad[i].stickX != old_gcaxes[i][0])
{
ev.axis.axis = 0;
ev.axis.pos = pad[i].stickX << 8;
write_eq(&ev);
old_gcaxes[i][0] = pad[i].stickX;
}
if(pad[i].stickY != old_gcaxes[i][1])
{
ev.axis.axis = 1;
ev.axis.pos = -(pad[i].stickY << 8);
write_eq(&ev);
old_gcaxes[i][1] = pad[i].stickY;
}
if(pad[i].substickX != old_gcaxes[i][2])
{
ev.axis.axis = 2;
ev.axis.pos = pad[i].substickX << 8;
write_eq(&ev);
old_gcaxes[i][0] = pad[i].substickX;
}
if(pad[i].substickY != old_gcaxes[i][3])
{
ev.axis.axis = 3;
ev.axis.pos = -(pad[i].substickY << 8);
write_eq(&ev);
old_gcaxes[i][1] = pad[i].substickY;
}
}
else
{
scan_buttons(i + 4, old_gcbtns[i], 0);
old_gcbtns[i] = 0;
ev.type = EVENT_AXIS_MOVE;
ev.axis.pad = i + 4;
ev.axis.pos = 0;
for(j = 0; j < 4; j++)
{
if(old_gcaxes[i][j])
{
ev.axis.axis = j;
write_eq(&ev);
old_gcaxes[i][j] = 0;
}
}
}
}
while(KEYBOARD_GetEvent(&ke))
{
ke.modifiers &= MOD_CAPSLOCK | MOD_NUMLOCK;
if(ke.modifiers != old_modifiers)
{
ev.type = EVENT_KEY_LOCKS;
ev.locks.locks = ke.modifiers;
write_eq(&ev);
old_modifiers = ke.modifiers;
}
ev.key.key = ke.keycode;
// Non-character keys mapped to the private use area
if((ke.symbol >= 0xE000) && (ke.symbol < 0xF900))
ev.key.unicode = 0;
else
ev.key.unicode = ke.symbol;
switch(ke.type)
{
default:
case KEYBOARD_CONNECTED:
case KEYBOARD_DISCONNECTED:
break;
case KEYBOARD_PRESSED:
ev.type = EVENT_KEY_DOWN;
write_eq(&ev);
break;
case KEYBOARD_RELEASED:
ev.type = EVENT_KEY_UP;
write_eq(&ev);
break;
}
}
ev.type = EVENT_MOUSE_MOVE;
ev.mmove.dx = ev.mmove.dy = 0;
while(MOUSE_GetEvent(&me))
{
ev.mmove.dx += me.rx;
ev.mmove.dy += me.ry;
me.button &= USB_MOUSE_BTN_MASK;
if(me.button != old_mousebtns)
{
if(ev.mmove.dx || ev.mmove.dy)
write_eq(&ev);
for(i = 1; i <= (me.button | old_mousebtns); i <<= 1)
{
if(i & (me.button ^ old_mousebtns))
{
if(i & me.button)
ev.type = EVENT_MOUSE_BUTTON_DOWN;
else
ev.type = EVENT_MOUSE_BUTTON_UP;
ev.mbutton.button = i;
write_eq(&ev);
}
}
old_mousebtns = me.button;
ev.type = EVENT_MOUSE_MOVE;
ev.mmove.dx = ev.mmove.dy = 0;
}
}
if(ev.mmove.dx || ev.mmove.dy)
write_eq(&ev);
}
static unsigned char DecodeJoy(unsigned short chan)
{
s8 pad_x = userInput[chan].pad.stickX;
s8 pad_y = userInput[chan].pad.stickY;
u32 jp = userInput[chan].pad.btns_h;
unsigned char J = 0;
#ifdef HW_RVL
s8 wm_ax = userInput[chan].WPAD_StickX(0);
s8 wm_ay = userInput[chan].WPAD_StickY(0);
u32 wp = userInput[chan].wpad->btns_h;
u32 exp_type;
if ( WPAD_Probe(chan, &exp_type) != 0 ) exp_type = WPAD_EXP_NONE;
#endif
/***
Gamecube Joystick input
***/
// Is XY inside the "zone"?
if (pad_x * pad_x + pad_y * pad_y > PADCAL * PADCAL)
{
if (pad_x > 0 && pad_y == 0) J |= JOY_RIGHT;
if (pad_x < 0 && pad_y == 0) J |= JOY_LEFT;
if (pad_x == 0 && pad_y > 0) J |= JOY_UP;
if (pad_x == 0 && pad_y < 0) J |= JOY_DOWN;
if (pad_x != 0 && pad_y != 0)
{
if ((float)pad_y / pad_x >= -2.41421356237 && (float)pad_y / pad_x < 2.41421356237)
{
if (pad_x >= 0)
J |= JOY_RIGHT;
else
J |= JOY_LEFT;
}
if ((float)pad_x / pad_y >= -2.41421356237 && (float)pad_x / pad_y < 2.41421356237)
{
if (pad_y >= 0)
J |= JOY_UP;
else
J |= JOY_DOWN;
}
}
}
#ifdef HW_RVL
/***
Wii Joystick (classic, nunchuk) input
***/
// Is XY inside the "zone"?
if (wm_ax * wm_ax + wm_ay * wm_ay > PADCAL * PADCAL)
{
/*** we don't want division by zero ***/
if (wm_ax > 0 && wm_ay == 0)
J |= JOY_RIGHT;
if (wm_ax < 0 && wm_ay == 0)
J |= JOY_LEFT;
if (wm_ax == 0 && wm_ay > 0)
J |= JOY_UP;
if (wm_ax == 0 && wm_ay < 0)
J |= JOY_DOWN;
if (wm_ax != 0 && wm_ay != 0)
{
/*** Recalc left / right ***/
float t;
t = (float) wm_ay / wm_ax;
if (t >= -2.41421356237 && t < 2.41421356237)
{
if (wm_ax >= 0)
J |= JOY_RIGHT;
else
J |= JOY_LEFT;
}
/*** Recalc up / down ***/
t = (float) wm_ax / wm_ay;
if (t >= -2.41421356237 && t < 2.41421356237)
{
if (wm_ay >= 0)
J |= JOY_UP;
else
J |= JOY_DOWN;
}
}
}
#endif
// Report pressed buttons (gamepads)
int i;
for (i = 0; i < MAXJP; i++)
{
if ( (jp & btnmap[CTRL_PAD][CTRLR_GCPAD][i]) // gamecube controller
#ifdef HW_RVL
|| ( (exp_type == WPAD_EXP_NONE) && (wp & btnmap[CTRL_PAD][CTRLR_WIIMOTE][i]) ) // wiimote
|| ( (exp_type == WPAD_EXP_CLASSIC) && (wp & btnmap[CTRL_PAD][CTRLR_CLASSIC][i]) ) // classic controller
|| ( (exp_type == WPAD_EXP_NUNCHUK) && (wp & btnmap[CTRL_PAD][CTRLR_NUNCHUK][i]) ) // nunchuk + wiimote
#endif
)
{
// if zapper is on, ignore all buttons except START and SELECT
if(GCSettings.Controller != CTRL_ZAPPER || nespadmap[i] == JOY_START || nespadmap[i] == JOY_SELECT)
{
if(rapidAlternator && nespadmap[i] == RAPID_A)
{
// activate rapid fire for A button
J |= JOY_A;
}
else if(rapidAlternator && nespadmap[i] == RAPID_B)
{
// activate rapid fire for B button
J |= JOY_B;
}
else if(nespadmap[i] > 0)
{
J |= nespadmap[i];
}
else
{
if(GameInfo->type == GIT_FDS) // FDS
{
/* the commands shouldn't be issued in parallel so
* we'll delay them so the virtual FDS has a chance
* to process them
*/
if(FDSSwitchRequested == 0)
FDSSwitchRequested = 1;
}
else
FCEUI_VSUniCoin(); // insert coin for VS Games
}
}
}
}
// zapper enabled
if(GCSettings.Controller == CTRL_ZAPPER)
{
int z; // NES port # (0 or 1)
if(GameInfo->type == GIT_VSUNI)
z = 0;
else
z = 1;
myzappers[z][2] = 0; // reset trigger to not pressed
// is trigger pressed?
if ( (jp & btnmap[CTRL_ZAPPER][CTRLR_GCPAD][0]) // gamecube controller
#ifdef HW_RVL
|| ( (exp_type == WPAD_EXP_NONE) && (wp & btnmap[CTRL_ZAPPER][CTRLR_WIIMOTE][0]) ) // wiimote
#endif
)
{
// report trigger press
myzappers[z][2] |= 2;
}
// VS zapper games
if ( (jp & btnmap[CTRL_ZAPPER][CTRLR_GCPAD][1]) // gamecube controller
#ifdef HW_RVL
|| ( (exp_type == WPAD_EXP_NONE) && (wp & btnmap[CTRL_ZAPPER][CTRLR_WIIMOTE][1]) ) // wiimote
#endif
)
{
FCEUI_VSUniCoin(); // insert coin for VS zapper games
}
// cursor position
UpdateCursorPosition(0); // update cursor for wiimote 1
myzappers[z][0] = pos_x;
myzappers[z][1] = pos_y;
// Report changes to FCE Ultra
zapperdata[z]->Update(z,myzappers[z],0);
}
return J;
}
static unsigned char DecodeJoy(unsigned short chan)
{
s8 pad_x = userInput[chan].pad.stickX;
s8 pad_y = userInput[chan].pad.stickY;
u32 jp = userInput[chan].pad.btns_h;
unsigned char J = 0;
#ifdef HW_RVL
s8 wm_ax = userInput[chan].WPAD_StickX(0);
s8 wm_ay = userInput[chan].WPAD_StickY(0);
u32 wp = userInput[chan].wpad->btns_h;
bool isWUPC = userInput[chan].wpad->exp.classic.type == 2;
u32 exp_type;
if ( WPAD_Probe(chan, &exp_type) != 0 )
exp_type = WPAD_EXP_NONE;
s16 wiidrc_ax = userInput[chan].wiidrcdata.stickX;
s16 wiidrc_ay = userInput[chan].wiidrcdata.stickY;
u32 wiidrcp = userInput[chan].wiidrcdata.btns_h;
#endif
/***
Gamecube Joystick input
***/
if (pad_y > ANALOG_SENSITIVITY)
J |= JOY_UP;
else if (pad_y < -ANALOG_SENSITIVITY)
J |= JOY_DOWN;
if (pad_x < -ANALOG_SENSITIVITY)
J |= JOY_LEFT;
else if (pad_x > ANALOG_SENSITIVITY)
J |= JOY_RIGHT;
#ifdef HW_RVL
/***
Wii Joystick (classic, nunchuk) input
***/
if (wm_ay > ANALOG_SENSITIVITY)
J |= JOY_UP;
else if (wm_ay < -ANALOG_SENSITIVITY)
J |= JOY_DOWN;
if (wm_ax < -ANALOG_SENSITIVITY)
J |= JOY_LEFT;
else if (wm_ax > ANALOG_SENSITIVITY)
J |= JOY_RIGHT;
/* WiiU Gamepad */
if (wiidrc_ay > ANALOG_SENSITIVITY)
J |= JOY_UP;
else if (wiidrc_ay < -ANALOG_SENSITIVITY)
J |= JOY_DOWN;
if (wiidrc_ax < -ANALOG_SENSITIVITY)
J |= JOY_LEFT;
else if (wiidrc_ax > ANALOG_SENSITIVITY)
J |= JOY_RIGHT;
#endif
bool zapper_triggered = false;
// zapper enabled
if(GCSettings.Controller == CTRL_ZAPPER)
{
int z; // NES port # (0 or 1)
if(GameInfo->type == GIT_VSUNI)
z = 0;
else
z = 1;
myzappers[z][2] = 0; // reset trigger to not pressed
// is trigger pressed?
if ( (jp & btnmap[CTRL_ZAPPER][CTRLR_GCPAD][0]) // gamecube controller
#ifdef HW_RVL
|| ( (exp_type == WPAD_EXP_NONE) && (wp & btnmap[CTRL_ZAPPER][CTRLR_WIIMOTE][0]) ) // wiimote
|| (wiidrcp & btnmap[CTRL_ZAPPER][CTRLR_WIIDRC][0]) // Wii U Gamepad
#endif
)
{
// report trigger press
myzappers[z][2] |= 2;
zapper_triggered = true;
}
// VS zapper games
if ( (jp & btnmap[CTRL_ZAPPER][CTRLR_GCPAD][1]) // gamecube controller
#ifdef HW_RVL
|| ( (exp_type == WPAD_EXP_NONE) && (wp & btnmap[CTRL_ZAPPER][CTRLR_WIIMOTE][1]) ) // wiimote
|| (wiidrcp & btnmap[CTRL_ZAPPER][CTRLR_WIIDRC][1]) // Wii U Gamepad
#endif
)
{
FCEUI_VSUniCoin(); // insert coin for VS zapper games
zapper_triggered = true;
}
// cursor position
int channel = 0; // by default, use wiimote 1
#ifdef HW_RVL
if (userInput[1].wpad->ir.valid)
{
channel = 1; // if wiimote 2 is connected, use wiimote 2 as zapper
}
#endif
UpdateCursorPosition(channel); // update cursor for wiimote
myzappers[z][0] = pos_x;
myzappers[z][1] = pos_y;
// Report changes to FCE Ultra
zapperdata[z]->Update(z,myzappers[z],0);
}
// Report pressed buttons (gamepads)
int i;
for (i = 0; i < MAXJP; i++)
{
if ( (jp & btnmap[CTRL_PAD][CTRLR_GCPAD][i]) // gamecube controller
#ifdef HW_RVL
|| ( (exp_type == WPAD_EXP_NONE) && (wp & btnmap[CTRL_PAD][CTRLR_WIIMOTE][i]) ) // wiimote
|| ( (exp_type == WPAD_EXP_CLASSIC && !isWUPC) && (wp & btnmap[CTRL_PAD][CTRLR_CLASSIC][i]) ) // classic controller
|| ( (exp_type == WPAD_EXP_CLASSIC && isWUPC) && (wp & btnmap[CTRL_PAD][CTRLR_WUPC][i]) ) // wii u pro controller
|| ( (exp_type == WPAD_EXP_NUNCHUK) && (wp & btnmap[CTRL_PAD][CTRLR_NUNCHUK][i]) ) // nunchuk + wiimote
|| ( (wiidrcp & btnmap[CTRL_PAD][CTRLR_WIIDRC][i]) ) // Wii U Gamepad
#endif
)
{
// if zapper is on, ignore all buttons except START and SELECT
if (!zapper_triggered)
{
if(rapidAlternator && nespadmap[i] == RAPID_A)
{
// activate rapid fire for A button
J |= JOY_A;
}
else if(rapidAlternator && nespadmap[i] == RAPID_B)
{
// activate rapid fire for B button
J |= JOY_B;
}
else if(nespadmap[i] > 0)
{
J |= nespadmap[i];
}
else
{
if(GameInfo->type == GIT_FDS) // FDS
{
/* the commands shouldn't be issued in parallel so
* we'll delay them so the virtual FDS has a chance
* to process them
*/
if(FDSSwitchRequested == 0)
FDSSwitchRequested = 1;
}
else
FCEUI_VSUniCoin(); // insert coin for VS Games
}
}
}
}
return J;
}
void IN_Commands (void)
{
// Fetch the pad state.
PAD_ScanPads();
WPAD_ScanPads();
keyboard_event KB_event;
while(KEYBOARD_GetEvent(&KB_event) > 0)
{
switch(KB_event.type)
{
case KEYBOARD_CONNECTED:
keyboard_connected = TRUE;
break;
case KEYBOARD_DISCONNECTED:
keyboard_connected = FALSE;
break;
case KEYBOARD_PRESSED:
if(!keyboard_shifted)
Key_Event(keycode_normal[KB_event.keycode], TRUE);
else
Key_Event(keycode_shifted[KB_event.keycode], TRUE);
if(keycode_normal[KB_event.keycode] == K_LSHIFT || keycode_normal[KB_event.keycode] == K_RSHIFT)
keyboard_shifted = TRUE;
break;
case KEYBOARD_RELEASED:
if(!keyboard_shifted)
Key_Event(keycode_normal[KB_event.keycode], FALSE);
else
Key_Event(keycode_shifted[KB_event.keycode], FALSE);
if(keycode_normal[KB_event.keycode] == K_LSHIFT || keycode_normal[KB_event.keycode] == K_RSHIFT)
keyboard_shifted = FALSE;
break;
}
}
u32 exp_type;
if ( WPAD_Probe(WPAD_CHAN_0, &exp_type) != 0 )
exp_type = WPAD_EXP_NONE;
if(exp_type == WPAD_EXP_NUNCHUK)
{
if(!nunchuk_connected)
wpad_previous_keys = 0x0000;
nunchuk_connected = TRUE;
classic_connected = FALSE;
wpad_keys = WPAD_ButtonsHeld(WPAD_CHAN_0);
pad_keys = 0x0000;
pad_previous_keys = 0x0000;
}
else if(exp_type == WPAD_EXP_CLASSIC)
{
if(!classic_connected)
wpad_previous_keys = 0x0000;
nunchuk_connected = FALSE;
classic_connected = TRUE;
wpad_keys = WPAD_ButtonsHeld(WPAD_CHAN_0);
pad_keys = 0x0000;
pad_previous_keys = 0x0000;
}
else
{
if(classic_connected || nunchuk_connected)
wpad_previous_keys = 0x0000;
nunchuk_connected = FALSE;
classic_connected = FALSE;
pad_keys = PAD_ButtonsHeld(PAD_CHAN0);
wpad_keys = WPAD_ButtonsHeld(WPAD_CHAN_0);
}
WPAD_IR(WPAD_CHAN_0, &pointer);
WPAD_Orientation(WPAD_CHAN_0, &orientation);
WPAD_Expansion(WPAD_CHAN_0, &expansion);
if (wiimote_connected && (wpad_keys & WPAD_BUTTON_MINUS))
{
// ELUTODO: we are using the previous frame wiimote position... FIX IT
in_osk = 1;
int line = (last_iry - OSK_YSTART) / (osk_line_size * (osk_line_size / osk_charsize)) - 1;
int col = (last_irx - OSK_XSTART) / (osk_col_size * (osk_col_size / osk_charsize)) - 1;
osk_coords[0] = last_irx;
osk_coords[1] = last_iry;
line = clamp(line, 0, osk_num_lines);
col = clamp(col, 0, osk_num_col);
if (nunchuk_connected && (wpad_keys & WPAD_NUNCHUK_BUTTON_Z))
osk_set = osk_shifted;
else
osk_set = osk_normal;
osk_selected = osk_set[line * osk_num_col + col];
if ((wpad_keys & WPAD_BUTTON_B) && osk_selected && (Sys_FloatTime() >= osk_last_press_time + osk_repeat_delay.value || osk_selected != osk_last_selected))
{
Key_Event((osk_selected), TRUE);
Key_Event((osk_selected), FALSE);
osk_last_selected = osk_selected;
osk_last_press_time = Sys_FloatTime();
}
}
else
{
// TODO: go back to the old method with buton mappings. The code was a lot cleaner that way
in_osk = 0;
if(classic_connected)
{
if ((wpad_previous_keys & WPAD_CLASSIC_BUTTON_LEFT) != (wpad_keys & WPAD_CLASSIC_BUTTON_LEFT))
{
// Send a press event.
Key_Event(K_LEFTARROW, ((wpad_keys & WPAD_CLASSIC_BUTTON_LEFT) == WPAD_CLASSIC_BUTTON_LEFT));
}
if ((wpad_previous_keys & WPAD_CLASSIC_BUTTON_RIGHT) != (wpad_keys & WPAD_CLASSIC_BUTTON_RIGHT))
{
// Send a press event.
Key_Event(K_RIGHTARROW, ((wpad_keys & WPAD_CLASSIC_BUTTON_RIGHT) == WPAD_CLASSIC_BUTTON_RIGHT));
}
if ((wpad_previous_keys & WPAD_CLASSIC_BUTTON_DOWN) != (wpad_keys & WPAD_CLASSIC_BUTTON_DOWN))
{
// Send a press event.
Key_Event(K_DOWNARROW, ((wpad_keys & WPAD_CLASSIC_BUTTON_DOWN) == WPAD_CLASSIC_BUTTON_DOWN));
}
if ((wpad_previous_keys & WPAD_CLASSIC_BUTTON_UP) != (wpad_keys & WPAD_CLASSIC_BUTTON_UP))
{
// Send a press event.
Key_Event(K_UPARROW, ((wpad_keys & WPAD_CLASSIC_BUTTON_UP) == WPAD_CLASSIC_BUTTON_UP));
}
if ((wpad_previous_keys & WPAD_CLASSIC_BUTTON_PLUS) != (wpad_keys & WPAD_CLASSIC_BUTTON_PLUS))
{
// Send a press event.
Key_Event(K_ESCAPE, ((wpad_keys & WPAD_CLASSIC_BUTTON_PLUS) == WPAD_CLASSIC_BUTTON_PLUS));
}
if ((wpad_previous_keys & WPAD_CLASSIC_BUTTON_A) != (wpad_keys & WPAD_CLASSIC_BUTTON_A))
{
// Send a press event.
Key_Event(K_JOY8, ((wpad_keys & WPAD_CLASSIC_BUTTON_A) == WPAD_CLASSIC_BUTTON_A));
}
if ((wpad_previous_keys & WPAD_CLASSIC_BUTTON_B) != (wpad_keys & WPAD_CLASSIC_BUTTON_B))
{
// Send a press event.
Key_Event(K_JOY9, ((wpad_keys & WPAD_CLASSIC_BUTTON_B) == WPAD_CLASSIC_BUTTON_B));
}
if ((wpad_previous_keys & WPAD_CLASSIC_BUTTON_MINUS) != (wpad_keys & WPAD_CLASSIC_BUTTON_MINUS))
{
// Send a press event.
Key_Event(K_JOY10, ((wpad_keys & WPAD_CLASSIC_BUTTON_MINUS) == WPAD_CLASSIC_BUTTON_MINUS));
}
if ((wpad_previous_keys & WPAD_CLASSIC_BUTTON_X) != (wpad_keys & WPAD_CLASSIC_BUTTON_X))
{
// Send a press event.
Key_Event(K_JOY13, ((wpad_keys & WPAD_CLASSIC_BUTTON_X) == WPAD_CLASSIC_BUTTON_X));
}
if ((wpad_previous_keys & WPAD_CLASSIC_BUTTON_Y) != (wpad_keys & WPAD_CLASSIC_BUTTON_Y))
{
// Send a press event.
Key_Event(K_JOY14, ((wpad_keys & WPAD_CLASSIC_BUTTON_Y) == WPAD_CLASSIC_BUTTON_Y));
}
if ((wpad_previous_keys & WPAD_CLASSIC_BUTTON_LEFT) != (wpad_keys & WPAD_CLASSIC_BUTTON_LEFT))
{
// Send a press event.
Key_Event(K_JOY15, ((wpad_keys & WPAD_CLASSIC_BUTTON_LEFT) == WPAD_CLASSIC_BUTTON_LEFT));
}
if ((wpad_previous_keys & WPAD_CLASSIC_BUTTON_RIGHT) != (wpad_keys & WPAD_CLASSIC_BUTTON_RIGHT))
{
// Send a press event.
Key_Event(K_JOY16, ((wpad_keys & WPAD_CLASSIC_BUTTON_RIGHT) == WPAD_CLASSIC_BUTTON_RIGHT));
}
if ((wpad_previous_keys & WPAD_CLASSIC_BUTTON_ZL) != (wpad_keys & WPAD_CLASSIC_BUTTON_ZL))
{
// Send a press event.
Key_Event(K_JOY17, ((wpad_keys & WPAD_CLASSIC_BUTTON_ZL) == WPAD_CLASSIC_BUTTON_ZL));
}
if ((wpad_previous_keys & WPAD_CLASSIC_BUTTON_ZR) != (wpad_keys & WPAD_CLASSIC_BUTTON_ZR))
{
// Send a press event.
Key_Event(K_JOY18, ((wpad_keys & WPAD_CLASSIC_BUTTON_ZR) == WPAD_CLASSIC_BUTTON_ZR));
}
}
else
{
if ((wpad_previous_keys & WPAD_BUTTON_LEFT) != (wpad_keys & WPAD_BUTTON_LEFT))
{
// Send a press event.
Key_Event(K_LEFTARROW, ((wpad_keys & WPAD_BUTTON_LEFT) == WPAD_BUTTON_LEFT));
}
if ((wpad_previous_keys & WPAD_BUTTON_RIGHT) != (wpad_keys & WPAD_BUTTON_RIGHT))
{
// Send a press event.
Key_Event(K_RIGHTARROW, ((wpad_keys & WPAD_BUTTON_RIGHT) == WPAD_BUTTON_RIGHT));
}
if ((wpad_previous_keys & WPAD_BUTTON_DOWN) != (wpad_keys & WPAD_BUTTON_DOWN))
{
// Send a press event.
Key_Event(K_DOWNARROW, ((wpad_keys & WPAD_BUTTON_DOWN) == WPAD_BUTTON_DOWN));
}
if ((wpad_previous_keys & WPAD_BUTTON_UP) != (wpad_keys & WPAD_BUTTON_UP))
{
// Send a press event.
Key_Event(K_UPARROW, ((wpad_keys & WPAD_BUTTON_UP) == WPAD_BUTTON_UP));
}
if ((wpad_previous_keys & WPAD_BUTTON_PLUS) != (wpad_keys & WPAD_BUTTON_PLUS))
{
// Send a press event.
Key_Event(K_ESCAPE, ((wpad_keys & WPAD_BUTTON_PLUS) == WPAD_BUTTON_PLUS));
}
if ((wpad_previous_keys & WPAD_BUTTON_A) != (wpad_keys & WPAD_BUTTON_A))
{
// Send a press event.
Key_Event(K_JOY8, ((wpad_keys & WPAD_BUTTON_A) == WPAD_BUTTON_A));
}
if ((wpad_previous_keys & WPAD_BUTTON_B) != (wpad_keys & WPAD_BUTTON_B))
{
// Send a press event.
Key_Event(K_JOY9, ((wpad_keys & WPAD_BUTTON_B) == WPAD_BUTTON_B));
}
if ((wpad_previous_keys & WPAD_BUTTON_MINUS) != (wpad_keys & WPAD_BUTTON_MINUS))
{
// Send a press event.
Key_Event(K_JOY10, ((wpad_keys & WPAD_BUTTON_MINUS) == WPAD_BUTTON_MINUS));
}
if ((wpad_previous_keys & WPAD_BUTTON_1) != (wpad_keys & WPAD_BUTTON_1))
{
// Send a press event.
Key_Event(K_JOY11, ((wpad_keys & WPAD_BUTTON_1) == WPAD_BUTTON_1));
}
if ((wpad_previous_keys & WPAD_BUTTON_2) != (wpad_keys & WPAD_BUTTON_2))
{
// Send a press event.
Key_Event(K_JOY12, ((wpad_keys & WPAD_BUTTON_2) == WPAD_BUTTON_2));
}
if(nunchuk_connected)
{
if ((wpad_previous_keys & WPAD_NUNCHUK_BUTTON_C) != (wpad_keys & WPAD_NUNCHUK_BUTTON_C))
{
// Send a press event.
Key_Event(K_JOY13, ((wpad_keys & WPAD_NUNCHUK_BUTTON_C) == WPAD_NUNCHUK_BUTTON_C));
}
if ((wpad_previous_keys & WPAD_NUNCHUK_BUTTON_Z) != (wpad_keys & WPAD_NUNCHUK_BUTTON_Z))
{
// Send a press event.
Key_Event(K_JOY14, ((wpad_keys & WPAD_NUNCHUK_BUTTON_Z) == WPAD_NUNCHUK_BUTTON_Z));
}
}
}
if(!nunchuk_connected && !classic_connected)
{
if ((pad_previous_keys & PAD_BUTTON_LEFT) != (pad_keys & PAD_BUTTON_LEFT))
{
// Send a press event.
Key_Event(K_LEFTARROW, ((pad_keys & PAD_BUTTON_LEFT) == PAD_BUTTON_LEFT));
}
if ((pad_previous_keys & PAD_BUTTON_RIGHT) != (pad_keys & PAD_BUTTON_RIGHT))
{
// Send a press event.
Key_Event(K_RIGHTARROW, ((pad_keys & PAD_BUTTON_RIGHT) == PAD_BUTTON_RIGHT));
}
if ((pad_previous_keys & PAD_BUTTON_DOWN) != (pad_keys & PAD_BUTTON_DOWN))
{
// Send a press event.
Key_Event(K_DOWNARROW, ((pad_keys & PAD_BUTTON_DOWN) == PAD_BUTTON_DOWN));
}
if ((pad_previous_keys & PAD_BUTTON_UP) != (pad_keys & PAD_BUTTON_UP))
{
// Send a press event.
Key_Event(K_UPARROW, ((pad_keys & PAD_BUTTON_UP) == PAD_BUTTON_UP));
}
if ((pad_previous_keys & PAD_BUTTON_A) != (pad_keys & PAD_BUTTON_A))
{
// Send a press event.
Key_Event(K_JOY8, ((pad_keys & PAD_BUTTON_A) == PAD_BUTTON_A));
}
if ((pad_previous_keys & PAD_BUTTON_B) != (pad_keys & PAD_BUTTON_B))
{
// Send a press event.
Key_Event(K_JOY9, ((pad_keys & PAD_BUTTON_B) == PAD_BUTTON_B));
}
if ((pad_previous_keys & PAD_BUTTON_X) != (pad_keys & PAD_BUTTON_X))
{
// Send a press event.
Key_Event(K_JOY10, ((pad_keys & PAD_BUTTON_X) == PAD_BUTTON_X));
}
if ((pad_previous_keys & PAD_BUTTON_Y) != (pad_keys & PAD_BUTTON_Y))
{
// Send a press event.
Key_Event(K_JOY10, ((pad_keys & PAD_BUTTON_Y) == PAD_BUTTON_Y));
}
if ((pad_previous_keys & PAD_TRIGGER_R) != (pad_keys & PAD_TRIGGER_R))
{
// Send a press event.
Key_Event(K_JOY11, ((pad_keys & PAD_TRIGGER_R) == PAD_TRIGGER_R));
}
if ((pad_previous_keys & PAD_TRIGGER_L) != (pad_keys & PAD_TRIGGER_L))
{
// Send a press event.
Key_Event(K_JOY12, ((pad_keys & PAD_TRIGGER_L) == PAD_TRIGGER_L));
}
if ((pad_previous_keys & PAD_TRIGGER_Z) != (pad_keys & PAD_TRIGGER_Z))
{
// Send a press event.
Key_Event(K_JOY13, ((pad_keys & PAD_TRIGGER_Z) == PAD_TRIGGER_Z));
}
if ((pad_previous_keys & PAD_BUTTON_START) != (pad_keys & PAD_BUTTON_START))
{
// Send a press event.
Key_Event(K_ESCAPE, ((pad_keys & PAD_BUTTON_START) == PAD_BUTTON_START));
}
pad_previous_keys = pad_keys;
}
}
wpad_previous_keys = wpad_keys;
}
u32 DecodeJoy(unsigned short pad)
{
signed char pad_x = PAD_StickX (pad);
signed char pad_y = PAD_StickY (pad);
signed char gc_px = PAD_SubStickX (0);
u32 jp = PAD_ButtonsHeld (pad);
u32 J = 0;
#ifdef HW_RVL
signed char wm_ax = WPAD_Stick ((u8)pad, 0, 0);
signed char wm_ay = WPAD_Stick ((u8)pad, 0, 1);
u32 wp = WPAD_ButtonsHeld (pad);
signed char wm_sx = WPAD_Stick (0,1,0); // CC right joystick
u32 exp_type;
if ( WPAD_Probe(pad, &exp_type) != 0 ) exp_type = WPAD_EXP_NONE;
#endif
/***
Gamecube Joystick input
***/
// Is XY inside the "zone"?
if (pad_x * pad_x + pad_y * pad_y > PADCAL * PADCAL)
{
if (pad_x > 0 && pad_y == 0) J |= VBA_RIGHT;
if (pad_x < 0 && pad_y == 0) J |= VBA_LEFT;
if (pad_x == 0 && pad_y > 0) J |= VBA_UP;
if (pad_x == 0 && pad_y < 0) J |= VBA_DOWN;
if (pad_x != 0 && pad_y != 0)
{
if ((float)pad_y / pad_x >= -2.41421356237 && (float)pad_y / pad_x < 2.41421356237)
{
if (pad_x >= 0)
J |= VBA_RIGHT;
else
J |= VBA_LEFT;
}
if ((float)pad_x / pad_y >= -2.41421356237 && (float)pad_x / pad_y < 2.41421356237)
{
if (pad_y >= 0)
J |= VBA_UP;
else
J |= VBA_DOWN;
}
}
}
#ifdef HW_RVL
/***
Wii Joystick (classic, nunchuk) input
***/
// Is XY inside the "zone"?
if (wm_ax * wm_ax + wm_ay * wm_ay > PADCAL * PADCAL)
{
/*** we don't want division by zero ***/
if (wm_ax > 0 && wm_ay == 0)
J |= VBA_RIGHT;
if (wm_ax < 0 && wm_ay == 0)
J |= VBA_LEFT;
if (wm_ax == 0 && wm_ay > 0)
J |= VBA_UP;
if (wm_ax == 0 && wm_ay < 0)
J |= VBA_DOWN;
if (wm_ax != 0 && wm_ay != 0)
{
/*** Recalc left / right ***/
float t;
t = (float) wm_ay / wm_ax;
if (t >= -2.41421356237 && t < 2.41421356237)
{
if (wm_ax >= 0)
J |= VBA_RIGHT;
else
J |= VBA_LEFT;
}
/*** Recalc up / down ***/
t = (float) wm_ax / wm_ay;
if (t >= -2.41421356237 && t < 2.41421356237)
{
if (wm_ay >= 0)
J |= VBA_UP;
else
J |= VBA_DOWN;
}
}
}
#endif
// Turbo feature
if(
(gc_px > 70)
#ifdef HW_RVL
|| (wm_sx > 70)
|| ((wp & WPAD_BUTTON_A) && (wp & WPAD_BUTTON_B))
#endif
)
J |= VBA_SPEED;
/*** Report pressed buttons (gamepads) ***/
int i;
for (i = 0; i < MAXJP; i++)
{
if ( (jp & gcpadmap[i]) // gamecube controller
#ifdef HW_RVL
|| ( (exp_type == WPAD_EXP_NONE) && (wp & wmpadmap[i]) ) // wiimote
|| ( (exp_type == WPAD_EXP_CLASSIC) && (wp & ccpadmap[i]) ) // classic controller
|| ( (exp_type == WPAD_EXP_NUNCHUK) && (wp & ncpadmap[i]) ) // nunchuk + wiimote
#endif
)
J |= vbapadmap[i];
}
if ((J & 48) == 48)
J &= ~16;
if ((J & 192) == 192)
J &= ~128;
return J;
}
int main(int argc, char* argv[])
{
u8 *tex_ptrone=GRRLIB_LoadTexture(handpointerred_png);
u8 *tex_ptrtwo=GRRLIB_LoadTexture(handpointergreen_png);
u8 *tex_back=GRRLIB_LoadJPG(bigmenuback_jpg, bigmenuback_jpg_size);
u8 *tex_fore=GRRLIB_LoadTexture(credits_png);
fatInitDefault();
GRRLIB_InitVideo();
WPAD_Init();
SYS_SetResetCallback(WiiResetPressed);
SYS_SetPowerCallback(WiiPowerPressed);
WPAD_SetPowerButtonCallback(WiimotePowerPressed);
rmode = VIDEO_GetPreferredMode(NULL);
AESND_Init(NULL);
MODPlay_Init(&mod_track);
Init_Voice();
AESND_Pause(0); // the sound loop is running now
// set the MOD song
if (MODPlay_SetMOD (&mod_track, dojo_dan_oriental_mod) < 0 ) {
MODPlay_Unload (&mod_track);
} else {
// set the music volume to the minimum so we don't hear the music before saved volume is known
MODPlay_SetVolume( &mod_track, 0,0);
MODPlay_Start (&mod_track);// Play the MOD
}
WPAD_SetDataFormat(WPAD_CHAN_ALL, WPAD_FMT_BTNS_ACC_IR);
WPAD_SetVRes(WPAD_CHAN_ALL, rmode->fbWidth, rmode->xfbHeight);
initMain();
MODPlay_SetVolume( &mod_track, opt_music, opt_music);
while( HWButton == 0) {
WPAD_ScanPads();
u32 wpad_one_down = WPAD_ButtonsDown(0);
u32 wpad_two_down = WPAD_ButtonsDown(1);
u32 type;
WPADData *wd_one, *wd_two;
WPAD_ReadPending(WPAD_CHAN_ALL, countevs);
WPAD_Probe(WPAD_CHAN_ALL, &type);
wd_one = WPAD_Data(0);
wd_two = WPAD_Data(1);
switch(main_mode) {
case STARTUP :
GRRLIB_FillScreen(0xFF000000);
GRRLIB_DrawImg(0, 0, 640, 480, tex_back, 0, 1, 1, alpha>255?255:alpha);
GRRLIB_DrawImg(68,308, 256, 80, tex_fore, 0, 1, 1, alpha>255?255:alpha);
if(alpha++>394 || wpad_one_down > 0) {
main_mode=MENU;
if(tex_back) free(tex_back);
if(tex_fore) free(tex_fore);
initMenu();
}
break;
case MENU :
GRRLIB_FillScreen(0xFF000000);
int menuopt = menuWiimote(wd_one,wpad_one_down);
if(menuopt==EXIT) {
if(tex_ptrone) free(tex_ptrone);
if(tex_ptrtwo) free(tex_ptrtwo);
}
if(menuopt>NOTHING) {
processMenuOption(menuopt);
if(main_mode==GAME) {
MODPlay_Unload (&mod_track);
if(opt_tileset==SPOOKY)
MODPlay_SetMOD (&mod_track, graveyard_mod);
else
if(opt_tileset==EGYPTIAN)
MODPlay_SetMOD (&mod_track, egypt_crap_mod);
else
if(opt_tileset==SIMPLE)
MODPlay_SetMOD (&mod_track, childhood_mod);
else
if(opt_tileset==SPACE)
MODPlay_SetMOD (&mod_track, nebulos_mod);
else
MODPlay_SetMOD (&mod_track, sushi_mod);
MODPlay_SetVolume( &mod_track, opt_music, opt_music);
MODPlay_Start (&mod_track);
}
else
drawMenu(wd_one);
}
else
drawMenu(wd_one);
break;
case GAME :
if(gameWiimote(wd_one,wpad_one_down,wd_two,wpad_two_down)) {
// we are exiting the game back to the menu
main_mode=MENU;
MODPlay_Unload (&mod_track);
MODPlay_SetMOD (&mod_track, dojo_dan_oriental_mod);
MODPlay_SetVolume( &mod_track, opt_music, opt_music);
MODPlay_Start (&mod_track);
killGame();
initMenu();
}
else {
drawGame();
}
break;
}
// alternate which pointer is on top every frame to not give the advantage to player one in two player mode
static int ticktock=0;
ticktock++;
if(wd_two->ir.valid && ticktock%2==0) {
if(main_mode==GAME && whatGameMode()==ONE_PLAYER_GAME) {
// don't display second pointer in one player mode
}
else
GRRLIB_DrawColImg(wd_two->ir.x - 9,wd_two->ir.y - 7,68,80,tex_ptrtwo,0,1,1,0xEEFFFFFF);
}
if(wd_one->ir.valid) {
GRRLIB_DrawColImg(wd_one->ir.x - 9,wd_one->ir.y - 7,68,80,tex_ptrone,0,1,1,0xEEFFFFFF);
}
if(wd_two->ir.valid && ticktock%2!=0) {
if(main_mode==GAME && whatGameMode()==ONE_PLAYER_GAME) {
// don't display second pointer in one player mode
}
else
GRRLIB_DrawColImg(wd_two->ir.x - 9,wd_two->ir.y - 7,68,80,tex_ptrtwo,0,1,1,0xEEFFFFFF);
}
if(wd_one->btns_h & WPAD_BUTTON_1) {
GRRLIB_ScrShot("MahjonggWii_Screen_%y%m%d_%H%M%S.png",time(NULL));
}
GRRLIB_Render();
}
// we are exiting, free the mallocs
switch( main_mode) {
case GAME:
killGame();
}
if(tex_ptrone) free(tex_ptrone);
if(tex_ptrtwo) free(tex_ptrtwo);
killMenuLanguages();
MODPlay_Unload (&mod_track);
Free_Voice();
WPAD_Shutdown();
GRRLIB_Stop();
saveConfig(FILE_CFG);
SYS_ResetSystem(HWButton, 0, 0);
return 0;
}
void decodepad (int pad)
{
int i, offset;
float t;
signed char pad_x = PAD_StickX (pad);
signed char pad_y = PAD_StickY (pad);
u32 jp = PAD_ButtonsHeld (pad);
#ifdef HW_RVL
signed char wm_ax = 0;
signed char wm_ay = 0;
u32 wp = 0;
wm_ax = WPAD_StickX ((u8)pad, 0);
wm_ay = WPAD_StickY ((u8)pad, 0);
wp = WPAD_ButtonsHeld (pad);
u32 exp_type;
if ( WPAD_Probe(pad, &exp_type) != 0 ) exp_type = WPAD_EXP_NONE;
#endif
/***
Gamecube Joystick input
***/
// Is XY inside the "zone"?
if (pad_x * pad_x + pad_y * pad_y > PADCAL * PADCAL)
{
/*** we don't want division by zero ***/
if (pad_x > 0 && pad_y == 0)
jp |= PAD_BUTTON_RIGHT;
if (pad_x < 0 && pad_y == 0)
jp |= PAD_BUTTON_LEFT;
if (pad_x == 0 && pad_y > 0)
jp |= PAD_BUTTON_UP;
if (pad_x == 0 && pad_y < 0)
jp |= PAD_BUTTON_DOWN;
if (pad_x != 0 && pad_y != 0)
{
/*** Recalc left / right ***/
t = (float) pad_y / pad_x;
if (t >= -2.41421356237 && t < 2.41421356237)
{
if (pad_x >= 0)
jp |= PAD_BUTTON_RIGHT;
else
jp |= PAD_BUTTON_LEFT;
}
/*** Recalc up / down ***/
t = (float) pad_x / pad_y;
if (t >= -2.41421356237 && t < 2.41421356237)
{
if (pad_y >= 0)
jp |= PAD_BUTTON_UP;
else
jp |= PAD_BUTTON_DOWN;
}
}
}
#ifdef HW_RVL
/***
Wii Joystick (classic, nunchuk) input
***/
// Is XY inside the "zone"?
if (wm_ax * wm_ax + wm_ay * wm_ay > PADCAL * PADCAL)
{
/*** we don't want division by zero ***/
if (wm_ax > 0 && wm_ay == 0)
wp |= WPAD_BUTTON_RIGHT | WPAD_CLASSIC_BUTTON_RIGHT;
if (wm_ax < 0 && wm_ay == 0)
wp |= WPAD_BUTTON_LEFT | WPAD_CLASSIC_BUTTON_LEFT;
if (wm_ax == 0 && wm_ay > 0)
wp |= WPAD_BUTTON_UP | WPAD_CLASSIC_BUTTON_UP;
if (wm_ax == 0 && wm_ay < 0)
wp |= WPAD_BUTTON_DOWN | WPAD_CLASSIC_BUTTON_DOWN;
if (wm_ax != 0 && wm_ay != 0)
{
/*** Recalc left / right ***/
t = (float) wm_ay / wm_ax;
if (t >= -2.41421356237 && t < 2.41421356237)
{
if (wm_ax >= 0)
wp |= WPAD_BUTTON_RIGHT | WPAD_CLASSIC_BUTTON_RIGHT;
else
wp |= WPAD_BUTTON_LEFT | WPAD_CLASSIC_BUTTON_LEFT;
}
/*** Recalc up / down ***/
t = (float) wm_ax / wm_ay;
if (t >= -2.41421356237 && t < 2.41421356237)
{
if (wm_ay >= 0)
wp |= WPAD_BUTTON_UP | WPAD_CLASSIC_BUTTON_UP;
else
wp |= WPAD_BUTTON_DOWN | WPAD_CLASSIC_BUTTON_DOWN;
}
}
}
#endif
/*** Fix offset to pad ***/
offset = ((pad + 1) << 4);
/*** Report pressed buttons (gamepads) ***/
for (i = 0; i < MAXJP; i++)
{
if ( (jp & gcpadmap[i]) // gamecube controller
#ifdef HW_RVL
|| ( (exp_type == WPAD_EXP_NONE) && (wp & wmpadmap[i]) ) // wiimote
|| ( (exp_type == WPAD_EXP_CLASSIC) && (wp & ccpadmap[i]) ) // classic controller
|| ( (exp_type == WPAD_EXP_NUNCHUK) && (wp & ncpadmap[i]) ) // nunchuk + wiimote
#endif
)
S9xReportButton (offset + i, true);
else
S9xReportButton (offset + i, false);
}
/*** Superscope ***/
if (Settings.SuperScopeMaster && pad == GCSettings.Superscope-1) // report only once
{
// buttons
offset = 0x50;
for (i = 0; i < 6; i++)
{
if ( jp & gcscopemap[i]
#ifdef HW_RVL
|| wp & wmscopemap[i]
#endif
)
S9xReportButton (offset + i, true);
else
S9xReportButton (offset + i, false);
}
// pointer
offset = 0x80;
UpdateCursorPosition (pad, cursor_x[0], cursor_y[0]);
S9xReportPointer(offset, (u16)cursor_x[0], (u16)cursor_y[0]);
}
/*** Mouse ***/
else if (Settings.MouseMaster && pad < GCSettings.Mouse)
{
// buttons
offset = 0x60+(2*pad);
for (i = 0; i < 2; i++)
{
if ( jp & gcmousemap[i]
#ifdef HW_RVL
|| wp & wmmousemap[i]
#endif
)
S9xReportButton (offset + i, true);
else
S9xReportButton (offset + i, false);
}
// pointer
offset = 0x81;
UpdateCursorPosition (pad, cursor_x[1+pad], cursor_y[1+pad]);
S9xReportPointer(offset+pad, (u16)cursor_x[1+pad], (u16)cursor_y[1+pad]);
}
/*** Justifier ***/
else if (Settings.JustifierMaster && pad < GCSettings.Justifier)
{
// buttons
offset = 0x70+(3*pad);
for (i = 0; i < 3; i++)
{
if ( jp & gcjustmap[i]
#ifdef HW_RVL
|| wp & wmjustmap[i]
#endif
)
S9xReportButton (offset + i, true);
else
S9xReportButton (offset + i, false);
}
// pointer
offset = 0x83;
UpdateCursorPosition (pad, cursor_x[3+pad], cursor_y[3+pad]);
S9xReportPointer(offset+pad, (u16)cursor_x[3+pad], (u16)cursor_y[3+pad]);
}
}
static void gx_input_poll(void *data)
{
(void)data;
pad_state[0] = 0;
pad_state[1] = 0;
pad_state[2] = 0;
pad_state[3] = 0;
analog_state[0][0][0] = analog_state[0][0][1] = analog_state[0][1][0] = analog_state[0][1][1] = 0;
analog_state[1][0][0] = analog_state[1][0][1] = analog_state[1][1][0] = analog_state[1][1][1] = 0;
analog_state[2][0][0] = analog_state[2][0][1] = analog_state[2][1][0] = analog_state[2][1][1] = 0;
analog_state[3][0][0] = analog_state[3][0][1] = analog_state[3][1][0] = analog_state[3][1][1] = 0;
PAD_ScanPads();
#ifdef HW_RVL
WPAD_ReadPending(WPAD_CHAN_ALL, NULL);
#endif
for (unsigned port = 0; port < MAX_PADS; port++)
{
uint32_t down = 0;
uint64_t *state_cur = &pad_state[port];
#ifdef HW_RVL
if (pad_detect_pending[port])
{
u32 *ptype = &pad_type[port];
pad_connect[port] = WPAD_Probe(port, ptype);
pad_detect_pending[port] = 0;
}
uint32_t connected = pad_connect[port];
uint32_t type = pad_type[port];
if (connected == WPAD_ERR_NONE)
{
WPADData *wpaddata = WPAD_Data(port);
down = wpaddata->btns_h;
*state_cur |= (down & WPAD_BUTTON_A) ? GX_WIIMOTE_A : 0;
*state_cur |= (down & WPAD_BUTTON_B) ? GX_WIIMOTE_B : 0;
*state_cur |= (down & WPAD_BUTTON_1) ? GX_WIIMOTE_1 : 0;
*state_cur |= (down & WPAD_BUTTON_2) ? GX_WIIMOTE_2 : 0;
*state_cur |= (down & WPAD_BUTTON_PLUS) ? GX_WIIMOTE_PLUS : 0;
*state_cur |= (down & WPAD_BUTTON_MINUS) ? GX_WIIMOTE_MINUS : 0;
*state_cur |= (down & WPAD_BUTTON_HOME) ? GX_WIIMOTE_HOME : 0;
// rotated d-pad on Wiimote
*state_cur |= (down & WPAD_BUTTON_UP) ? GX_WIIMOTE_LEFT : 0;
*state_cur |= (down & WPAD_BUTTON_DOWN) ? GX_WIIMOTE_RIGHT : 0;
*state_cur |= (down & WPAD_BUTTON_LEFT) ? GX_WIIMOTE_DOWN : 0;
*state_cur |= (down & WPAD_BUTTON_RIGHT) ? GX_WIIMOTE_UP : 0;
expansion_t *exp = &wpaddata->exp;
if (type == WPAD_EXP_CLASSIC)
{
*state_cur |= (down & WPAD_CLASSIC_BUTTON_A) ? GX_CLASSIC_A : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_B) ? GX_CLASSIC_B : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_X) ? GX_CLASSIC_X : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_Y) ? GX_CLASSIC_Y : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_UP) ? GX_CLASSIC_UP : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_DOWN) ? GX_CLASSIC_DOWN : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_LEFT) ? GX_CLASSIC_LEFT : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_RIGHT) ? GX_CLASSIC_RIGHT : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_PLUS) ? GX_CLASSIC_PLUS : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_MINUS) ? GX_CLASSIC_MINUS : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_HOME) ? GX_CLASSIC_HOME : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_FULL_L) ? GX_CLASSIC_L_TRIGGER : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_FULL_R) ? GX_CLASSIC_R_TRIGGER : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_ZL) ? GX_CLASSIC_ZL_TRIGGER : 0;
*state_cur |= (down & WPAD_CLASSIC_BUTTON_ZR) ? GX_CLASSIC_ZR_TRIGGER : 0;
float ljs_mag = exp->classic.ljs.mag;
float ljs_ang = exp->classic.ljs.ang;
float rjs_mag = exp->classic.rjs.mag;
float rjs_ang = exp->classic.rjs.ang;
if (ljs_mag > 1.0f)
ljs_mag = 1.0f;
else if (ljs_mag < -1.0f)
ljs_mag = -1.0f;
if (rjs_mag > 1.0f)
rjs_mag = 1.0f;
else if (rjs_mag < -1.0f)
rjs_mag = -1.0f;
double ljs_val_x = ljs_mag * sin(M_PI * ljs_ang / 180.0);
double ljs_val_y = -ljs_mag * cos(M_PI * ljs_ang / 180.0);
double rjs_val_x = rjs_mag * sin(M_PI * rjs_ang / 180.0);
double rjs_val_y = -rjs_mag * cos(M_PI * rjs_ang / 180.0);
int16_t ls_x = (int16_t)(ljs_val_x * 32767.0f);
int16_t ls_y = (int16_t)(ljs_val_y * 32767.0f);
int16_t rs_x = (int16_t)(rjs_val_x * 32767.0f);
int16_t rs_y = (int16_t)(rjs_val_y * 32767.0f);
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;
}
else if (type == WPAD_EXP_NUNCHUK)
{
// wiimote is held upright with nunchuk, do not change d-pad orientation
*state_cur |= (down & WPAD_BUTTON_UP) ? GX_WIIMOTE_UP : 0;
*state_cur |= (down & WPAD_BUTTON_DOWN) ? GX_WIIMOTE_DOWN : 0;
*state_cur |= (down & WPAD_BUTTON_LEFT) ? GX_WIIMOTE_LEFT : 0;
*state_cur |= (down & WPAD_BUTTON_RIGHT) ? GX_WIIMOTE_RIGHT : 0;
*state_cur |= (down & WPAD_NUNCHUK_BUTTON_Z) ? GX_NUNCHUK_Z : 0;
*state_cur |= (down & WPAD_NUNCHUK_BUTTON_C) ? 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;
}
}
#endif
if (SI_GetType(port) & SI_TYPE_GC)
{
down = PAD_ButtonsHeld(port);
*state_cur |= (down & PAD_BUTTON_A) ? GX_GC_A : 0;
*state_cur |= (down & PAD_BUTTON_B) ? GX_GC_B : 0;
*state_cur |= (down & PAD_BUTTON_X) ? GX_GC_X : 0;
*state_cur |= (down & PAD_BUTTON_Y) ? GX_GC_Y : 0;
*state_cur |= (down & PAD_BUTTON_UP) ? GX_GC_UP : 0;
*state_cur |= (down & PAD_BUTTON_DOWN) ? GX_GC_DOWN : 0;
*state_cur |= (down & PAD_BUTTON_LEFT) ? GX_GC_LEFT : 0;
*state_cur |= (down & PAD_BUTTON_RIGHT) ? GX_GC_RIGHT : 0;
*state_cur |= (down & PAD_BUTTON_START) ? GX_GC_START : 0;
*state_cur |= (down & PAD_TRIGGER_Z) ? GX_GC_Z_TRIGGER : 0;
*state_cur |= ((down & PAD_TRIGGER_L) || PAD_TriggerL(port) > 127) ? GX_GC_L_TRIGGER : 0;
*state_cur |= ((down & PAD_TRIGGER_R) || PAD_TriggerR(port) > 127) ? GX_GC_R_TRIGGER : 0;
int16_t ls_x = (int16_t)PAD_StickX(port) * 256;
int16_t ls_y = (int16_t)PAD_StickY(port) * -256;
int16_t rs_x = (int16_t)PAD_SubStickX(port) * 256;
int16_t 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;
if ((*state_cur & (GX_GC_START | GX_GC_Z_TRIGGER | GX_GC_L_TRIGGER | GX_GC_R_TRIGGER)) == (GX_GC_START | GX_GC_Z_TRIGGER | GX_GC_L_TRIGGER | GX_GC_R_TRIGGER))
*state_cur |= GX_WIIMOTE_HOME;
}
}
uint64_t *state_p1 = &pad_state[0];
uint64_t *lifecycle_state = &g_extern.lifecycle_state;
*lifecycle_state &= ~(
(1ULL << RARCH_FAST_FORWARD_HOLD_KEY) |
(1ULL << RARCH_LOAD_STATE_KEY) |
(1ULL << RARCH_SAVE_STATE_KEY) |
(1ULL << RARCH_STATE_SLOT_PLUS) |
(1ULL << RARCH_STATE_SLOT_MINUS) |
(1ULL << RARCH_REWIND) |
(1ULL << RARCH_QUIT_KEY) |
(1ULL << RARCH_MENU_TOGGLE));
if (g_menu)
{
*state_p1 |= GX_WIIMOTE_HOME;
g_menu = false;
}
if (*state_p1 & (GX_WIIMOTE_HOME
#ifdef HW_RVL
| GX_CLASSIC_HOME
#endif
))
*lifecycle_state |= (1ULL << RARCH_MENU_TOGGLE);
}
int HomeMenu::GetChoice()
{
for (int i = 0; i < 4; i++)
{
if (WPAD_Probe(i, NULL) == WPAD_ERR_NONE)
{
int level = (WPAD_BatteryLevel(i) / 100.0) * 4;
if (level > 4) level = 4;
if (level <= 1) {
BatteryBarImg[i]->SetImage(BatteryBarRedImgData);
BatteryImg[i]->SetImage(BatteryRedImgData);
} else {
BatteryBarImg[i]->SetImage(BatteryBarImgData);
BatteryImg[i]->SetImage(BatteryImgData);
}
BatteryImg[i]->SetTile(level);
BatteryBtn[i]->SetAlpha(255);
PlayerText[i]->SetAlpha(255);
}
else
{
BatteryBarImg[i]->SetImage(BatteryBarImgData);
BatteryImg[i]->SetTile(0);
BatteryBtn[i]->SetAlpha(130);
PlayerText[i]->SetAlpha(100);
}
}
if (TopBtn->GetState() == STATE_CLICKED)
{
TopBtn->ResetState();
FadeOut();
choice = 0; // return to SaveGame Manager GX
}
else if (BottomBtn->GetState() == STATE_CLICKED)
{
BottomBtn->ResetState();
FadeOut();
choice = 0; // return to SaveGame Manager GX
}
else if (ExitBtn->GetState() == STATE_CLICKED)
{
ExitBtn->ResetState();
this->SetState(STATE_DISABLED);
int ret = WindowPrompt(tr("Back to Loader"), 0, tr("Homebrew Channel"), tr("Wii Menu"), tr("Cancel"), 0, false);
if (ret == 1)
Sys_BackToLoader();
else if(ret == 2)
Sys_LoadMenu();
this->SetState(STATE_DEFAULT);
}
else if (ShutdownBtn->GetState() == STATE_CLICKED)
{
ShutdownBtn->ResetState();
this->SetState(STATE_DISABLED);
int ret = WindowPrompt(tr("ShutDown Wii"), 0, tr("Full Shutdown"), tr("Idle Shutdown"), tr("Cancel"), 0, false);
if (ret == 1)
Sys_ShutdownToStandby();
else if (ret == 2)
Sys_ShutdownToIdle();
this->SetState(STATE_DEFAULT);
}
else if (BottomBtn->GetState() == STATE_SELECTED)
{
WiimoteBtn->SetPosition(WiimoteBtn->GetLeft(), 210);
}
else if (BottomBtn->GetState() != STATE_SELECTED)
{
WiimoteBtn->SetPosition(WiimoteBtn->GetLeft(), 232);
}
return choice;
}
void ogc_input__set_defaults(void)
{
int i;
/* set default key mapping for each type of devices */
for (i=0; i<4; i++)
{
config.pad_keymap[i][KEY_BUTTONA] = PAD_BUTTON_B;
config.pad_keymap[i][KEY_BUTTONB] = PAD_BUTTON_A;
config.pad_keymap[i][KEY_BUTTONC] = PAD_BUTTON_X;
config.pad_keymap[i][KEY_START] = PAD_BUTTON_START;
config.pad_keymap[i][KEY_MENU] = PAD_TRIGGER_Z;
config.pad_keymap[i][KEY_BUTTONX] = PAD_TRIGGER_L;
config.pad_keymap[i][KEY_BUTTONY] = PAD_BUTTON_Y;
config.pad_keymap[i][KEY_BUTTONZ] = PAD_TRIGGER_R;
}
#ifdef HW_RVL
u32 exp;
for (i=0; i<4; i++)
{
/* WIIMOTE */
config.wpad_keymap[i*3 + WPAD_EXP_NONE][KEY_BUTTONA] = WPAD_BUTTON_A;
config.wpad_keymap[i*3 + WPAD_EXP_NONE][KEY_BUTTONB] = WPAD_BUTTON_2;
config.wpad_keymap[i*3 + WPAD_EXP_NONE][KEY_BUTTONC] = WPAD_BUTTON_1;
config.wpad_keymap[i*3 + WPAD_EXP_NONE][KEY_START] = WPAD_BUTTON_PLUS;
config.wpad_keymap[i*3 + WPAD_EXP_NONE][KEY_MENU] = WPAD_BUTTON_HOME;
config.wpad_keymap[i*3 + WPAD_EXP_NONE][KEY_BUTTONX] = 0;
config.wpad_keymap[i*3 + WPAD_EXP_NONE][KEY_BUTTONY] = 0;
config.wpad_keymap[i*3 + WPAD_EXP_NONE][KEY_BUTTONZ] = 0;
/* WIIMOTE + NUNCHUK */
config.wpad_keymap[i*3 + WPAD_EXP_NUNCHUK][KEY_BUTTONA] = WPAD_NUNCHUK_BUTTON_Z;
config.wpad_keymap[i*3 + WPAD_EXP_NUNCHUK][KEY_BUTTONB] = WPAD_BUTTON_A;
config.wpad_keymap[i*3 + WPAD_EXP_NUNCHUK][KEY_BUTTONC] = WPAD_BUTTON_B;
config.wpad_keymap[i*3 + WPAD_EXP_NUNCHUK][KEY_START] = WPAD_BUTTON_PLUS;
config.wpad_keymap[i*3 + WPAD_EXP_NUNCHUK][KEY_MENU] = WPAD_BUTTON_HOME;
config.wpad_keymap[i*3 + WPAD_EXP_NUNCHUK][KEY_BUTTONX] = WPAD_NUNCHUK_BUTTON_C;
config.wpad_keymap[i*3 + WPAD_EXP_NUNCHUK][KEY_BUTTONY] = WPAD_BUTTON_1;
config.wpad_keymap[i*3 + WPAD_EXP_NUNCHUK][KEY_BUTTONZ] = WPAD_BUTTON_2;
/* CLASSIC CONTROLLER */
config.wpad_keymap[i*3 + WPAD_EXP_CLASSIC][KEY_BUTTONA] = WPAD_CLASSIC_BUTTON_Y;
config.wpad_keymap[i*3 + WPAD_EXP_CLASSIC][KEY_BUTTONB] = WPAD_CLASSIC_BUTTON_B;
config.wpad_keymap[i*3 + WPAD_EXP_CLASSIC][KEY_BUTTONC] = WPAD_CLASSIC_BUTTON_A;
config.wpad_keymap[i*3 + WPAD_EXP_CLASSIC][KEY_START] = WPAD_CLASSIC_BUTTON_PLUS;
config.wpad_keymap[i*3 + WPAD_EXP_CLASSIC][KEY_MENU] = WPAD_CLASSIC_BUTTON_HOME;
config.wpad_keymap[i*3 + WPAD_EXP_CLASSIC][KEY_BUTTONX] = WPAD_CLASSIC_BUTTON_ZL;
config.wpad_keymap[i*3 + WPAD_EXP_CLASSIC][KEY_BUTTONY] = WPAD_CLASSIC_BUTTON_X;
config.wpad_keymap[i*3 + WPAD_EXP_CLASSIC][KEY_BUTTONZ] = WPAD_CLASSIC_BUTTON_ZR;
}
#endif
/* default device assignation */
for (i=0; i<MAX_DEVICES; i++)
{
#ifdef HW_RVL
if (i < 4)
{
/* autodetect connected controller */
exp = 255;
WPAD_Probe(i, &exp);
if (exp <= WPAD_EXP_CLASSIC)
{
/* set expansion controller (or wiimote if no expansion) as default */
config.input[i].device = exp + 1;
config.input[i].port = i;
}
else
{
/* set gamepad as default */
config.input[i].device = 0;
config.input[i].port = i;
/* look for unassigned wiimotes */
int j;
for (j=0; j<i; j++)
{
/* expansion is used, wiimote is free */
if (config.input[j].device > 1)
{
/* assign wiimote */
config.input[i].device = 1;
config.input[i].port = j;
}
}
}
}
else
{
/* set gamepad if not assigned */
config.input[i].device = (config.input[i-4].device == 0) ? -1 : 0;
}
#else
/* set gamepad as default */
config.input[i].device = (i < 4) ? 0 : -1;
#endif
}
}
