The-Homebrew-Cloud/vbagx
2
0
Fork 0
mirror of https://github.com/dborth/vbagx.git synced 2024-11-25 12:06:53 +01:00
Code Issues Packages Projects Releases Wiki Activity
683fd17219
vbagx/source/input.cpp

988 lines
24 KiB
C++
Raw Blame History

/****************************************************************************
* Visual Boy Advance GX
*
* Tantric 2008-2009
*
* input.cpp
*
* Wii/Gamecube controller management
***************************************************************************/
#include <gccore.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ogcsys.h>
#include <unistd.h>
#include <wiiuse/wpad.h>
#include <ogc/lwp_watchdog.h>
#include "vbagx.h"
#include "button_mapping.h"
#include "audio.h"
#include "video.h"
#include "input.h"
#include "gameinput.h"
#include "vbasupport.h"
#include "fastmath.h"
#include "gui/gui.h"
#include "vba/gba/GBA.h"
#include "vba/gba/bios.h"
#include "vba/gba/GBAinline.h"
#define ANALOG_SENSITIVITY 30
int rumbleRequest[4] = {0,0,0,0};
GuiTrigger userInput[4];
#ifdef HW_RVL
static int rumbleCount[4] = {0,0,0,0};
#endif
static bool cartridgeRumble = false, possibleCartridgeRumble = false;
static int gameRumbleCount = 0, menuRumbleCount = 0, rumbleCountAlready = 0;
static unsigned int vbapadmap[10]; // VBA controller buttons
u32 btnmap[6][10]; // button mapping
void ResetControls(int wiiCtrl)
{
int i;
// VBA controller buttons
// All other pads are mapped to this
i=0;
vbapadmap[i++] = VBA_BUTTON_B;
vbapadmap[i++] = VBA_BUTTON_A;
vbapadmap[i++] = VBA_BUTTON_SELECT;
vbapadmap[i++] = VBA_BUTTON_START;
vbapadmap[i++] = VBA_UP;
vbapadmap[i++] = VBA_DOWN;
vbapadmap[i++] = VBA_LEFT;
vbapadmap[i++] = VBA_RIGHT;
vbapadmap[i++] = VBA_BUTTON_L;
vbapadmap[i++] = VBA_BUTTON_R;
/*** Gamecube controller Padmap ***/
if(wiiCtrl == CTRLR_GCPAD || wiiCtrl == -1)
{
i=0;
btnmap[CTRLR_GCPAD][i++] = PAD_BUTTON_B;
btnmap[CTRLR_GCPAD][i++] = PAD_BUTTON_A;
btnmap[CTRLR_GCPAD][i++] = PAD_TRIGGER_Z;
btnmap[CTRLR_GCPAD][i++] = PAD_BUTTON_START;
btnmap[CTRLR_GCPAD][i++] = PAD_BUTTON_UP;
btnmap[CTRLR_GCPAD][i++] = PAD_BUTTON_DOWN;
btnmap[CTRLR_GCPAD][i++] = PAD_BUTTON_LEFT;
btnmap[CTRLR_GCPAD][i++] = PAD_BUTTON_RIGHT;
btnmap[CTRLR_GCPAD][i++] = PAD_TRIGGER_L;
btnmap[CTRLR_GCPAD][i++] = PAD_TRIGGER_R;
}
/*** Wiimote Padmap ***/
if(wiiCtrl == CTRLR_WIIMOTE || wiiCtrl == -1)
{
i=0;
btnmap[CTRLR_WIIMOTE][i++] = WPAD_BUTTON_1;
btnmap[CTRLR_WIIMOTE][i++] = WPAD_BUTTON_2;
btnmap[CTRLR_WIIMOTE][i++] = WPAD_BUTTON_MINUS;
btnmap[CTRLR_WIIMOTE][i++] = WPAD_BUTTON_PLUS;
btnmap[CTRLR_WIIMOTE][i++] = WPAD_BUTTON_RIGHT;
btnmap[CTRLR_WIIMOTE][i++] = WPAD_BUTTON_LEFT;
btnmap[CTRLR_WIIMOTE][i++] = WPAD_BUTTON_UP;
btnmap[CTRLR_WIIMOTE][i++] = WPAD_BUTTON_DOWN;
btnmap[CTRLR_WIIMOTE][i++] = WPAD_BUTTON_B;
btnmap[CTRLR_WIIMOTE][i++] = WPAD_BUTTON_A;
}
/*** Classic Controller Padmap ***/
if(wiiCtrl == CTRLR_CLASSIC || wiiCtrl == -1)
{
i=0;
btnmap[CTRLR_CLASSIC][i++] = WPAD_CLASSIC_BUTTON_Y;
btnmap[CTRLR_CLASSIC][i++] = WPAD_CLASSIC_BUTTON_B;
btnmap[CTRLR_CLASSIC][i++] = WPAD_CLASSIC_BUTTON_MINUS;
btnmap[CTRLR_CLASSIC][i++] = WPAD_CLASSIC_BUTTON_PLUS;
btnmap[CTRLR_CLASSIC][i++] = WPAD_CLASSIC_BUTTON_UP;
btnmap[CTRLR_CLASSIC][i++] = WPAD_CLASSIC_BUTTON_DOWN;
btnmap[CTRLR_CLASSIC][i++] = WPAD_CLASSIC_BUTTON_LEFT;
btnmap[CTRLR_CLASSIC][i++] = WPAD_CLASSIC_BUTTON_RIGHT;
btnmap[CTRLR_CLASSIC][i++] = WPAD_CLASSIC_BUTTON_FULL_L;
btnmap[CTRLR_CLASSIC][i++] = WPAD_CLASSIC_BUTTON_FULL_R;
}
/*** Nunchuk + wiimote Padmap ***/
if(wiiCtrl == CTRLR_NUNCHUK || wiiCtrl == -1)
{
i=0;
btnmap[CTRLR_NUNCHUK][i++] = WPAD_NUNCHUK_BUTTON_C;
btnmap[CTRLR_NUNCHUK][i++] = WPAD_NUNCHUK_BUTTON_Z;
btnmap[CTRLR_NUNCHUK][i++] = WPAD_BUTTON_MINUS;
btnmap[CTRLR_NUNCHUK][i++] = WPAD_BUTTON_PLUS;
btnmap[CTRLR_NUNCHUK][i++] = WPAD_BUTTON_UP;
btnmap[CTRLR_NUNCHUK][i++] = WPAD_BUTTON_DOWN;
btnmap[CTRLR_NUNCHUK][i++] = WPAD_BUTTON_LEFT;
btnmap[CTRLR_NUNCHUK][i++] = WPAD_BUTTON_RIGHT;
btnmap[CTRLR_NUNCHUK][i++] = WPAD_BUTTON_2;
btnmap[CTRLR_NUNCHUK][i++] = WPAD_BUTTON_1;
}
/*** Wii U Pro Padmap ***/
if(wiiCtrl == CTRLR_WUPC || wiiCtrl == -1)
{
i=0;
btnmap[CTRLR_WUPC][i++] = WPAD_CLASSIC_BUTTON_Y;
btnmap[CTRLR_WUPC][i++] = WPAD_CLASSIC_BUTTON_B;
btnmap[CTRLR_WUPC][i++] = WPAD_CLASSIC_BUTTON_MINUS;
btnmap[CTRLR_WUPC][i++] = WPAD_CLASSIC_BUTTON_PLUS;
btnmap[CTRLR_WUPC][i++] = WPAD_CLASSIC_BUTTON_UP;
btnmap[CTRLR_WUPC][i++] = WPAD_CLASSIC_BUTTON_DOWN;
btnmap[CTRLR_WUPC][i++] = WPAD_CLASSIC_BUTTON_LEFT;
btnmap[CTRLR_WUPC][i++] = WPAD_CLASSIC_BUTTON_RIGHT;
btnmap[CTRLR_WUPC][i++] = WPAD_CLASSIC_BUTTON_FULL_L;
btnmap[CTRLR_WUPC][i++] = WPAD_CLASSIC_BUTTON_FULL_R;
}
/*** Wii U Gamepad Padmap ***/
if(wiiCtrl == CTRLR_WIIDRC || wiiCtrl == -1)
{
i=0;
btnmap[CTRLR_WIIDRC][i++] = WIIDRC_BUTTON_Y;
btnmap[CTRLR_WIIDRC][i++] = WIIDRC_BUTTON_B;
btnmap[CTRLR_WIIDRC][i++] = WIIDRC_BUTTON_MINUS;
btnmap[CTRLR_WIIDRC][i++] = WIIDRC_BUTTON_PLUS;
btnmap[CTRLR_WIIDRC][i++] = WIIDRC_BUTTON_UP;
btnmap[CTRLR_WIIDRC][i++] = WIIDRC_BUTTON_DOWN;
btnmap[CTRLR_WIIDRC][i++] = WIIDRC_BUTTON_LEFT;
btnmap[CTRLR_WIIDRC][i++] = WIIDRC_BUTTON_RIGHT;
btnmap[CTRLR_WIIDRC][i++] = WIIDRC_BUTTON_L;
btnmap[CTRLR_WIIDRC][i++] = WIIDRC_BUTTON_R;
}
}
/****************************************************************************
* UpdatePads
*
* Scans pad and wpad
***************************************************************************/
void
UpdatePads()
{
#ifdef HW_RVL
WiiDRC_ScanPads();
WPAD_ScanPads();
#endif
PAD_ScanPads();
for(int i=3; i >= 0; i--)
{
userInput[i].pad.btns_d = PAD_ButtonsDown(i);
userInput[i].pad.btns_u = PAD_ButtonsUp(i);
userInput[i].pad.btns_h = PAD_ButtonsHeld(i);
userInput[i].pad.stickX = PAD_StickX(i);
userInput[i].pad.stickY = PAD_StickY(i);
userInput[i].pad.substickX = PAD_SubStickX(i);
userInput[i].pad.substickY = PAD_SubStickY(i);
userInput[i].pad.triggerL = PAD_TriggerL(i);
userInput[i].pad.triggerR = PAD_TriggerR(i);
}
#ifdef HW_RVL
if(WiiDRC_Inited() && WiiDRC_Connected())
{
userInput[0].wiidrcdata.btns_d = WiiDRC_ButtonsDown();
userInput[0].wiidrcdata.btns_u = WiiDRC_ButtonsUp();
userInput[0].wiidrcdata.btns_h = WiiDRC_ButtonsHeld();
userInput[0].wiidrcdata.stickX = WiiDRC_lStickX();
userInput[0].wiidrcdata.stickY = WiiDRC_lStickY();
userInput[0].wiidrcdata.substickX = WiiDRC_rStickX();
userInput[0].wiidrcdata.substickY = WiiDRC_rStickY();
}
#endif
}
/****************************************************************************
* SetupPads
*
* Sets up userInput triggers for use
***************************************************************************/
void
SetupPads()
{
PAD_Init();
#ifdef HW_RVL
// read wiimote accelerometer and IR data
WPAD_SetDataFormat(WPAD_CHAN_ALL,WPAD_FMT_BTNS_ACC_IR);
WPAD_SetVRes(WPAD_CHAN_ALL, screenwidth, screenheight);
#endif
for(int i=0; i < 4; i++)
{
userInput[i].chan = i;
#ifdef HW_RVL
userInput[i].wpad = WPAD_Data(i);
#endif
}
}
/****************************************************************************
* ShutoffRumble
***************************************************************************/
void ShutoffRumble()
{
#ifdef HW_RVL
if(CONF_GetPadMotorMode() == 0)
return;
for(int i=0;i<4;i++)
{
WPAD_Rumble(i, 0);
rumbleCount[i] = 0;
rumbleRequest[i] = 0;
}
#endif
PAD_ControlMotor(PAD_CHAN0, PAD_MOTOR_STOP);
}
/****************************************************************************
* DoRumble
***************************************************************************/
void DoRumble(int i)
{
#ifdef HW_RVL
if(CONF_GetPadMotorMode() == 0 || !GCSettings.Rumble) return;
if(rumbleRequest[i] && rumbleCount[i] < 3)
{
WPAD_Rumble(i, 1); // rumble on
rumbleCount[i]++;
}
else if(rumbleRequest[i])
{
rumbleCount[i] = 12;
rumbleRequest[i] = 0;
}
else
{
if(rumbleCount[i])
rumbleCount[i]--;
WPAD_Rumble(i, 0); // rumble off
}
#endif
}
static int SilenceNeeded = 0;
static void updateRumble()
{
if(!GCSettings.Rumble) return;
bool r = false;
if (ConfigRequested) r = (menuRumbleCount > 0);
else r = cartridgeRumble || possibleCartridgeRumble || (gameRumbleCount > 0) || (menuRumbleCount > 0);
if (SilenceNeeded > 0)
{
if (r)
{
SilenceNeeded = 5;
// It will always be greater than 0 after that!
r = false;
}
else
{
if (--SilenceNeeded > 0) r = false;
}
}
#ifdef HW_RVL
// Rumble wii remote 0
WPAD_Rumble(0, r);
#endif
PAD_ControlMotor(PAD_CHAN0, r?PAD_MOTOR_RUMBLE:PAD_MOTOR_STOP);
}
void updateRumbleFrame()
{
if(!GCSettings.Rumble) return;
// If we already rumbled continuously for more than 50 frames,
// then disable rumbling for a while.
if (rumbleCountAlready > 70) {
SilenceNeeded = 5;
rumbleCountAlready = 0;
} else if (ConfigRequested) {
if (menuRumbleCount>0) ++rumbleCountAlready;
else rumbleCountAlready=0;
} else {
if (gameRumbleCount>0 || menuRumbleCount>0 || possibleCartridgeRumble)
++rumbleCountAlready;
else rumbleCountAlready=0;
}
updateRumble();
if (gameRumbleCount>0 && !ConfigRequested) --gameRumbleCount;
if (menuRumbleCount>0) --menuRumbleCount;
}
void systemPossibleCartridgeRumble(bool RumbleOn) {
possibleCartridgeRumble = RumbleOn;
updateRumble();
}
void systemCartridgeRumble(bool RumbleOn) {
cartridgeRumble = RumbleOn;
possibleCartridgeRumble = false;
updateRumble();
}
void systemGameRumble(int RumbleForFrames) {
if (RumbleForFrames > gameRumbleCount) gameRumbleCount = RumbleForFrames;
}
void systemGameRumbleOnlyFor(int OnlyRumbleForFrames) {
gameRumbleCount = OnlyRumbleForFrames;
}
u32 StandardMovement(unsigned short chan)
{
u32 J = 0;
s8 pad_x = userInput[chan].pad.stickX;
s8 pad_y = userInput[chan].pad.stickY;
#ifdef HW_RVL
s8 wm_ax = userInput[0].WPAD_StickX(0);
s8 wm_ay = userInput[0].WPAD_StickY(0);
s16 wiidrc_ax = userInput[chan].wiidrcdata.stickX;
s16 wiidrc_ay = userInput[chan].wiidrcdata.stickY;
#endif
/***
Gamecube Joystick input, same as normal
***/
if (pad_y > ANALOG_SENSITIVITY)
J |= VBA_UP;
else if (pad_y < -ANALOG_SENSITIVITY)
J |= VBA_DOWN;
if (pad_x < -ANALOG_SENSITIVITY)
J |= VBA_LEFT;
else if (pad_x > ANALOG_SENSITIVITY)
J |= VBA_RIGHT;
#ifdef HW_RVL
/***
Wii Joystick (classic, nunchuk) input
***/
if (wm_ay > ANALOG_SENSITIVITY)
J |= VBA_UP;
else if (wm_ay < -ANALOG_SENSITIVITY)
J |= VBA_DOWN;
if (wm_ax < -ANALOG_SENSITIVITY)
J |= VBA_LEFT;
else if (wm_ax > ANALOG_SENSITIVITY)
J |= VBA_RIGHT;
/* Wii U Gamepad */
if (wiidrc_ay > ANALOG_SENSITIVITY)
J |= VBA_UP;
else if (wiidrc_ay < -ANALOG_SENSITIVITY)
J |= VBA_DOWN;
if (wiidrc_ax < -ANALOG_SENSITIVITY)
J |= VBA_LEFT;
else if (wiidrc_ax > ANALOG_SENSITIVITY)
J |= VBA_RIGHT;
#endif
return J;
}
u32 StandardDPad(unsigned short pad)
{
u32 J = 0;
u32 jp = userInput[pad].pad.btns_h;
#ifdef HW_RVL
u32 exp_type;
if ( WPAD_Probe(pad, &exp_type) != 0 )
exp_type = WPAD_EXP_NONE;
u32 wp = userInput[pad].wpad->btns_h;
if (wp & WPAD_BUTTON_RIGHT)
J |= VBA_RIGHT;
else if (wp & WPAD_BUTTON_LEFT)
J |= VBA_LEFT;
if (wp & WPAD_BUTTON_UP)
J |= VBA_UP;
else if (wp & WPAD_BUTTON_DOWN)
J |= VBA_DOWN;
if (exp_type == WPAD_EXP_CLASSIC)
{
if (wp & WPAD_CLASSIC_BUTTON_UP)
J |= VBA_UP;
else if (wp & WPAD_CLASSIC_BUTTON_DOWN)
J |= VBA_DOWN;
if (wp & WPAD_CLASSIC_BUTTON_LEFT)
J |= VBA_LEFT;
else if (wp & WPAD_CLASSIC_BUTTON_RIGHT)
J |= VBA_RIGHT;
}
/* Wii U Gamepad */
u32 wiidrcp = userInput[pad].wiidrcdata.btns_h;
if (wiidrcp & WIIDRC_BUTTON_UP)
J |= VBA_UP;
else if (wiidrcp & WIIDRC_BUTTON_DOWN)
J |= VBA_DOWN;
if (wiidrcp & WIIDRC_BUTTON_LEFT)
J |= VBA_LEFT;
else if (wiidrcp & WIIDRC_BUTTON_RIGHT)
J |= VBA_RIGHT;
#endif
if (jp & PAD_BUTTON_UP)
J |= VBA_UP;
else if (jp & PAD_BUTTON_DOWN)
J |= VBA_DOWN;
if (jp & PAD_BUTTON_LEFT)
J |= VBA_LEFT;
else if (jp & PAD_BUTTON_RIGHT)
J |= VBA_RIGHT;
return J;
}
u32 StandardSideways(unsigned short pad)
{
u32 J = 0;
#ifdef HW_RVL
u32 wp = userInput[pad].wpad->btns_h;
if (wp & WPAD_BUTTON_RIGHT)
J |= VBA_UP;
else if (wp & WPAD_BUTTON_LEFT)
J |= VBA_DOWN;
if (wp & WPAD_BUTTON_UP)
J |= VBA_LEFT;
else if (wp & WPAD_BUTTON_DOWN)
J |= VBA_RIGHT;
if (wp & WPAD_BUTTON_PLUS)
J |= VBA_BUTTON_START;
if (wp & WPAD_BUTTON_MINUS)
J |= VBA_BUTTON_SELECT;
if (wp & WPAD_BUTTON_1)
J |= VBA_BUTTON_B;
if (wp & WPAD_BUTTON_2)
J |= VBA_BUTTON_A;
if (cartridgeType == 2)
{
if (wp & WPAD_BUTTON_A)
J |= VBA_BUTTON_R;
if (wp & WPAD_BUTTON_B)
J |= VBA_BUTTON_L;
}
else
{
if (wp & WPAD_BUTTON_B || wp & WPAD_BUTTON_A)
J |= VBA_SPEED;
}
#endif
return J;
}
u32 StandardClassic(unsigned short pad)
{
u32 J = 0;
#ifdef HW_RVL
u32 wp = userInput[pad].wpad->btns_h;
if (wp & WPAD_CLASSIC_BUTTON_RIGHT)
J |= VBA_RIGHT;
else if (wp & WPAD_CLASSIC_BUTTON_LEFT)
J |= VBA_LEFT;
if (wp & WPAD_CLASSIC_BUTTON_UP)
J |= VBA_UP;
else if (wp & WPAD_CLASSIC_BUTTON_DOWN)
J |= VBA_DOWN;
if (wp & WPAD_CLASSIC_BUTTON_PLUS)
J |= VBA_BUTTON_START;
if (wp & WPAD_CLASSIC_BUTTON_MINUS)
J |= VBA_BUTTON_SELECT;
if (wp & WPAD_CLASSIC_BUTTON_FULL_L || wp & WPAD_CLASSIC_BUTTON_ZL)
J |= VBA_BUTTON_L;
if (wp & WPAD_CLASSIC_BUTTON_FULL_R || wp & WPAD_CLASSIC_BUTTON_ZR)
J |= VBA_BUTTON_R;
if (wp & WPAD_CLASSIC_BUTTON_A)
J |= VBA_BUTTON_A;
if (wp & WPAD_CLASSIC_BUTTON_B)
J |= VBA_BUTTON_B;
if (wp & WPAD_CLASSIC_BUTTON_Y || wp & WPAD_CLASSIC_BUTTON_X)
J |= VBA_SPEED;
#endif
return J;
}
u32 StandardGamecube(unsigned short pad)
{
u32 J = 0;
u32 jp = userInput[pad].pad.btns_h;
if (jp & PAD_BUTTON_UP)
J |= VBA_UP;
else if (jp & PAD_BUTTON_DOWN)
J |= VBA_DOWN;
if (jp & PAD_BUTTON_LEFT)
J |= VBA_LEFT;
else if (jp & PAD_BUTTON_RIGHT)
J |= VBA_RIGHT;
if (jp & PAD_BUTTON_A)
J |= VBA_BUTTON_A;
if (jp & PAD_BUTTON_B)
J |= VBA_BUTTON_B;
if (jp & PAD_BUTTON_START)
J |= VBA_BUTTON_START;
if (jp & PAD_BUTTON_X)
J |= VBA_BUTTON_SELECT;
if (jp & PAD_TRIGGER_L)
J |= VBA_BUTTON_L;
if (jp & PAD_TRIGGER_R)
J |= VBA_BUTTON_R;
if (jp & PAD_TRIGGER_Z || jp & PAD_BUTTON_Y)
J |= VBA_SPEED;
return J;
}
u32 DecodeGamecube(unsigned short pad)
{
u32 J = 0;
u32 jp = userInput[pad].pad.btns_h;
for (u32 i = 0; i < MAXJP; ++i)
{
if (jp & btnmap[CTRLR_GCPAD][i])
J |= vbapadmap[i];
}
return J;
}
u32 DecodeWiimote(unsigned short pad)
{
u32 J = 0;
#ifdef HW_RVL
WPADData * wp = WPAD_Data(pad);
u32 wpad_btns_h = wp->btns_h;
if(wp->exp.type == WPAD_EXP_NONE)
{
for (u32 i = 0; i < MAXJP; ++i)
{
if (wpad_btns_h & btnmap[CTRLR_WIIMOTE][i] )
J |= vbapadmap[i];
}
}
#endif
return J;
}
u32 DecodeClassic(unsigned short pad)
{
u32 J = 0;
#ifdef HW_RVL
WPADData * wp = WPAD_Data(pad);
u32 wpad_btns_h = wp->btns_h;
if(wp->exp.type == WPAD_EXP_CLASSIC){
if (wp->exp.classic.type == 2) {
for (u32 i = 0; i < MAXJP; ++i){
if (wpad_btns_h & btnmap[CTRLR_WUPC][i] )
J |= vbapadmap[i];
}
}
else {
for (u32 i = 0; i < MAXJP; ++i){
if (wpad_btns_h & btnmap[CTRLR_CLASSIC][i] )
J |= vbapadmap[i];
}
}
}
#endif
return J;
}
u32 DecodeNunchuk(unsigned short pad)
{
u32 J = 0;
#ifdef HW_RVL
WPADData * wp = WPAD_Data(pad);
u32 wpad_btns_h = wp->btns_h;
if(wp->exp.type == WPAD_EXP_NUNCHUK){
for (u32 i = 0; i < MAXJP; ++i){
if (wpad_btns_h & btnmap[CTRLR_NUNCHUK][i] )
J |= vbapadmap[i];
}
}
#endif
return J;
}
#ifdef HW_RVL
static u32 CCToGC(u32 w) {
u32 gc = 0;
if (w & WPAD_CLASSIC_BUTTON_A) gc |= PAD_BUTTON_A;
if (w & WPAD_CLASSIC_BUTTON_B) gc |= PAD_BUTTON_B;
if (w & WPAD_CLASSIC_BUTTON_X) gc |= PAD_BUTTON_X;
if (w & WPAD_CLASSIC_BUTTON_Y) gc |= PAD_BUTTON_Y;
if (w & WPAD_CLASSIC_BUTTON_PLUS) gc |= PAD_BUTTON_START;
if (w & WPAD_CLASSIC_BUTTON_MINUS) gc |= 0;
if (w & (WPAD_CLASSIC_BUTTON_ZL | WPAD_CLASSIC_BUTTON_ZR)) gc |= PAD_TRIGGER_Z;
if (w & WPAD_CLASSIC_BUTTON_FULL_L) gc |= PAD_TRIGGER_L;
if (w & WPAD_CLASSIC_BUTTON_FULL_R) gc |= PAD_TRIGGER_R;
if (w & WPAD_CLASSIC_BUTTON_UP) gc |= PAD_BUTTON_UP;
else if (w & WPAD_CLASSIC_BUTTON_DOWN) gc |= PAD_BUTTON_DOWN;
if (w & WPAD_CLASSIC_BUTTON_LEFT) gc |= PAD_BUTTON_LEFT;
else if (w & WPAD_CLASSIC_BUTTON_RIGHT) gc |= PAD_BUTTON_RIGHT;
return gc;
}
#endif
// For developers who don't have gamecube pads but need to test gamecube input
u32 PAD_ButtonsHeldFake(unsigned short pad)
{
u32 gc = 0;
#ifdef HW_RVL
if (userInput[pad].wpad->exp.type == WPAD_EXP_CLASSIC) {
gc = CCToGC(userInput[pad].wpad->btns_h);
}
#endif
return gc;
}
u32 PAD_ButtonsDownFake(unsigned short pad)
{
u32 gc = 0;
#ifdef HW_RVL
if (userInput[pad].wpad->exp.type == WPAD_EXP_CLASSIC) {
gc = CCToGC(userInput[pad].wpad->btns_d);
}
#endif
return gc;
}
u32 PAD_ButtonsUpFake(unsigned short pad)
{
u32 gc = 0;
#ifdef HW_RVL
if (userInput[pad].wpad->exp.type == WPAD_EXP_CLASSIC) {
gc = CCToGC(userInput[pad].wpad->btns_u);
}
#endif
return gc;
}
/****************************************************************************
* DecodeJoy
*
* Reads the STATE (not changes) from a controller and reports
* this STATE (not changes) to VBA
****************************************************************************/
static u32 DecodeJoy(unsigned short pad)
{
#ifdef HW_RVL
CursorX = userInput[pad].wpad->ir.x;
CursorY = userInput[pad].wpad->ir.y;
CursorValid = userInput[pad].wpad->ir.valid;
#else
CursorX = CursorY = CursorValid = 0;
#endif
// check for games that should have special Wii controls
if (GCSettings.WiiControls)
switch (RomIdCode & 0xFFFFFF)
{
// Zelda
case ZELDA1:
return Zelda1Input(pad);
case ZELDA2:
return Zelda2Input(pad);
case ALINKTOTHEPAST:
return ALinkToThePastInput(pad);
case LINKSAWAKENING:
return LinksAwakeningInput(pad);
case ORACLEOFAGES:
return OracleOfAgesInput(pad);
case ORACLEOFSEASONS:
return OracleOfSeasonsInput(pad);
case MINISHCAP:
return MinishCapInput(pad);
// Metroid
case METROID0:
return MetroidZeroInput(pad);
case METROID1:
return Metroid1Input(pad);
case METROID2:
return Metroid2Input(pad);
case METROID4:
return MetroidFusionInput(pad);
// TMNT
case TMNT1:
return TMNT1Input(pad);
case TMNT2:
return TMNT2Input(pad);
case TMNT3:
return TMNT3Input(pad);
case TMNTGBA:
return TMNTGBAInput(pad);
case TMNTGBA2:
return TMNTGBA2Input(pad);
case TMNT:
return TMNTInput(pad);
// Medal Of Honor
case MOHUNDERGROUND:
return MohUndergroundInput(pad);
case MOHINFILTRATOR:
return MohInfiltratorInput(pad);
// Harry Potter
case HARRYPOTTER1GBC:
return HarryPotter1GBCInput(pad);
case HARRYPOTTER2GBC:
return HarryPotter2GBCInput(pad);
case HARRYPOTTER1:
return HarryPotter1Input(pad);
case HARRYPOTTER2:
return HarryPotter2Input(pad);
case HARRYPOTTER3:
return HarryPotter3Input(pad);
case HARRYPOTTER4:
return HarryPotter4Input(pad);
case HARRYPOTTER5:
return HarryPotter5Input(pad);
// Mario
case MARIO1CLASSIC:
case MARIO2CLASSIC:
return Mario1ClassicInput(pad);
case MARIO1DX:
return Mario1DXInput(pad);
case MARIO2ADV:
return Mario2Input(pad);
case MARIO3ADV:
return Mario3Input(pad);
case MARIOWORLD:
return MarioWorldInput(pad);
case YOSHIISLAND:
return YoshiIslandInput(pad);
case MARIOLAND1:
return MarioLand1Input(pad);
case MARIOLAND2:
return MarioLand2Input(pad);
case YOSHIUG:
return UniversalGravitationInput(pad);
// Mario Kart
case MARIOKART:
return MarioKartInput(pad);
// Lego Star Wars
case LSW1:
return LegoStarWars1Input(pad);
case LSW2:
return LegoStarWars2Input(pad);
// Star Wars
case SWOBIWAN:
return SWObiWanInput(pad);
case SWJPB:
return SWJediPowerBattlesInput(pad);
case SWEP2:
return SWEpisode2Input(pad);
case SWEP3:
return SWEpisode3Input(pad);
case SWEP4:
return SWEpisode4Input(pad);
case SWEP5:
return SWEpisode5Input(pad);
case SWEP6:
return SWEpisode6Input(pad);
case SWTRILOGY:
return SWTrilogyInput(pad);
case SWNDA:
return SWNDAInput(pad);
case SWYODA:
return SWYodaStoriesInput(pad);
// Mortal Kombat
case MK1:
return MK1Input(pad);
case MK12:
return MK12Input(pad);
case MK2:
return MK2Input(pad);
case MK3:
return MK3Input(pad);
case MK4:
return MK4Input(pad);
case MKA:
return MKAInput(pad);
case MKDA:
return MKDAInput(pad);
case MKTE:
return MKTEInput(pad);
// WarioWare
case TWISTED:
return TwistedInput(pad);
// Kirby
case KIRBYTNT:
case KIRBYTNTJ:
return KirbyTntInput(pad);
// Boktai
case BOKTAI1:
return BoktaiInput(pad);
case BOKTAI2:
case BOKTAI3:
return Boktai2Input(pad);
// One Piece
case ONEPIECE:
return OnePieceInput(pad);
// Lord of the Rings
case HOBBIT:
return HobbitInput(pad);
case LOTR1:
return FellowshipOfTheRingInput(pad);
case LOTR2:
case LOTR3:
return ReturnOfTheKingInput(pad);
// Castlevania
case CVADVENTURE:
return CastlevaniaAdventureInput(pad);
case CVBELMONT:
return CastlevaniaBelmontInput(pad);
case CVLEGENDS:
return CastlevaniaLegendsInput(pad);
case CVCIRCLEMOON:
case CVHARMONY:
case CVARIA:
return CastlevaniaCircleMoonInput(pad);
case KIDDRACULA:
return KidDraculaInput(pad);
}
// the function result, J, is a combination of flags for all the VBA buttons that are down
u32 J = StandardMovement(pad);
// Turbo feature
if(userInput[0].pad.substickX > 70 ||
userInput[0].WPAD_Stick(1,0) > 70 ||
userInput[0].wiidrcdata.substickX > 45)
J |= VBA_SPEED;
// Report pressed buttons (gamepads)
u32 pad_btns_h = userInput[pad].pad.btns_h; // GCN
u32 wiidrcp_btns_h = userInput[pad].wiidrcdata.btns_h;
#ifdef HW_RVL
u32 wpad_btns_h = userInput[pad].wpad->btns_h;
int wpad_exp_type = userInput[pad].wpad->exp.type;
bool isWUPC = userInput[pad].wpad->exp.classic.type == 2;
if(wpad_exp_type == WPAD_EXP_NONE)
{ // wiimote
for (u32 i =0; i < MAXJP; ++i)
{
if ((pad_btns_h & btnmap[CTRLR_GCPAD][i]) // gamecube controller
|| ( wiidrcp_btns_h & btnmap[CTRLR_WIIDRC][i] ) //wii u gamepad
|| ( (wpad_btns_h & btnmap[CTRLR_WIIMOTE][i]) ))
J |= vbapadmap[i];
}
}
else if(wpad_exp_type == WPAD_EXP_CLASSIC)
{ // classic controller
if (wp->exp.classic.type == 2) {
for (u32 i = 0; i < MAXJP; ++i)
{
if (wpad_btns_h & btnmap[CTRLR_WUPC][i] )
J |= vbapadmap[i];
}
}
else {
for (u32 i = 0; i < MAXJP; ++i)
{
if ((pad_btns_h & btnmap[CTRLR_GCPAD][i]) // gamecube controller
|| ( wiidrcp_btns_h & btnmap[CTRLR_WIIDRC][i] ) //wiiu gamepad
|| ( (wpad_btns_h & btnmap[CTRLR_CLASSIC][i]) ))
J |= vbapadmap[i];
}
}
}
else if(wpad_exp_type == WPAD_EXP_NUNCHUK)
{ // nunchuk + wiimote
for (u32 i =0; i < MAXJP; ++i)
{
if ((pad_btns_h & btnmap[CTRLR_GCPAD][i]) // gamecube controller
|| ( (wpad_btns_h & btnmap[CTRLR_NUNCHUK][i]) ))
J |= vbapadmap[i];
}
}
else
// Check out this trickery!
// If all else fails OR if HW_RVL is undefined, the result is the same
#endif
{
for (u32 i = 0; i < MAXJP; ++i)
{
if ((pad_btns_h & btnmap[CTRLR_GCPAD][i]) || (wiidrcp_btns_h & btnmap[CTRLR_WIIDRC][i]))
J |= vbapadmap[i];
}
}
return J;
}
bool MenuRequested()
{
for(int i=0; i<4; i++) {
if (
(userInput[i].pad.substickX < -70)
#ifdef HW_RVL
|| (userInput[i].wpad->btns_h & WPAD_BUTTON_HOME) ||
(userInput[i].wpad->btns_h & WPAD_CLASSIC_BUTTON_HOME) ||
(userInput[i].wiidrcdata.btns_h & WIIDRC_BUTTON_HOME)
#endif
)
{
return true;
}
}
return false;
}
u32 GetJoy(int pad)
{
// request to go back to menu
if (MenuRequested())
{
ScreenshotRequested = 1;
updateRumbleFrame();
return 0;
}
u32 J = DecodeJoy(pad);
// don't allow up+down or left+right
if ((J & 48) == 48)
J &= ~16;
if ((J & 192) == 192)
J &= ~128;
updateRumbleFrame();
return J;
}
Reference in New Issue View Git Blame Copy Permalink