The-Homebrew-Cloud/Genesis-Plus-GX
2
0
Fork 0
mirror of https://github.com/ekeeke/Genesis-Plus-GX.git synced 2024-11-17 16:19:23 +01:00
Code Issues Packages Projects Releases Wiki Activity
7316507339
Genesis-Plus-GX/gx/gx_input.c

1936 lines
59 KiB
C
Raw Blame History

/****************************************************************************
* gx_input.c
*
* Genesis Plus GX input support
*
* Copyright Eke-Eke (2007-2023)
*
* Redistribution and use of this code or any derivative works are permitted
* provided that the following conditions are met:
*
* - Redistributions may not be sold, nor may they be used in a commercial
* product or activity.
*
* - Redistributions that are modified from the original source must include the
* complete source code, including the source code for all components used by a
* binary built from the modified sources. However, as a special exception, the
* source code distributed need not include anything that is normally distributed
* (in either source or binary form) with the major components (compiler, kernel,
* and so on) of the operating system on which the executable runs, unless that
* component itself accompanies the executable.
*
* - Redistributions must reproduce the above copyright notice, this list of
* conditions and the following disclaimer in the documentation and/or other
* materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************************/
#include "shared.h"
#include "font.h"
#include "gui.h"
#include "menu.h"
#include "cheats.h"
#ifdef HW_RVL
#include <ogc/usbmouse.h>
#include "wiidrc.h"
#endif
/* Analog sticks sensitivity */
#define ANALOG_SENSITIVITY 30
/* Delay before held keys triggering */
/* higher is the value, longer must the key remain held */
#define HELD_DELAY 30
/* Direction & selection update speed when a key is being held */
/* lower is the value, faster is the key update (min value = 1) */
#define HELD_SPEED 2
/* Configurable keys */
#define KEY_BUTTONA 0
#define KEY_BUTTONB 1
#define KEY_BUTTONC 2
#define KEY_START 3
#define KEY_BUTTONX 4
#define KEY_BUTTONY 5
#define KEY_BUTTONZ 6
#define KEY_MODE 7
#define KEY_MENU 8
#ifdef HW_RVL
#define PAD_UP 0
#define PAD_DOWN 1
#define PAD_LEFT 2
#define PAD_RIGHT 3
/* default directions mapping */
static u32 wpad_dirmap[4][4] =
{
{WPAD_BUTTON_RIGHT, WPAD_BUTTON_LEFT, WPAD_BUTTON_UP, WPAD_BUTTON_DOWN}, /* WIIMOTE */
{WPAD_BUTTON_UP, WPAD_BUTTON_DOWN, WPAD_BUTTON_LEFT, WPAD_BUTTON_RIGHT}, /* WIIMOTE + NUNCHUK */
{WPAD_CLASSIC_BUTTON_UP, WPAD_CLASSIC_BUTTON_DOWN, WPAD_CLASSIC_BUTTON_LEFT, WPAD_CLASSIC_BUTTON_RIGHT}, /* CLASSIC */
{WIIDRC_BUTTON_UP, WIIDRC_BUTTON_DOWN, WIIDRC_BUTTON_LEFT, WIIDRC_BUTTON_RIGHT} /* WIIU GAMEPAD */
};
#define WPAD_BUTTONS_HELD (WPAD_BUTTON_UP | WPAD_BUTTON_DOWN | WPAD_BUTTON_LEFT | WPAD_BUTTON_RIGHT | \
WPAD_BUTTON_MINUS | WPAD_BUTTON_PLUS | WPAD_BUTTON_A | WPAD_BUTTON_2 | \
WPAD_CLASSIC_BUTTON_UP | WPAD_CLASSIC_BUTTON_DOWN | WPAD_CLASSIC_BUTTON_LEFT | WPAD_CLASSIC_BUTTON_RIGHT | \
WPAD_CLASSIC_BUTTON_FULL_L | WPAD_CLASSIC_BUTTON_FULL_R | WPAD_CLASSIC_BUTTON_A)
#define WIIU_BUTTONS_HELD (WIIDRC_BUTTON_UP | WIIDRC_BUTTON_DOWN | WIIDRC_BUTTON_LEFT | WIIDRC_BUTTON_RIGHT | \
WIIDRC_BUTTON_MINUS | WIIDRC_BUTTON_PLUS | WIIDRC_BUTTON_A | \
WIIDRC_BUTTON_L | WIIDRC_BUTTON_ZL | WIIDRC_BUTTON_R | WIIDRC_BUTTON_ZR)
#endif
#define PAD_BUTTONS_HELD (PAD_BUTTON_UP | PAD_BUTTON_DOWN | PAD_BUTTON_LEFT | PAD_BUTTON_RIGHT | \
PAD_TRIGGER_L | PAD_TRIGGER_R | PAD_BUTTON_A)
static char keyname[MAX_KEYS][16];
static int held_cnt = 0;
static int inputs_disabled = 0;
/***************************************************************************************/
/* Gamecube PAD support */
/***************************************************************************************/
static void pad_config(int chan, int first_key, int last_key)
{
u16 p = 0;
char msg[64];
/* disable background PAD scanning */
inputs_disabled = 1;
/* Check if PAD is connected */
VIDEO_WaitVSync();
if (!(PAD_ScanPads() & (1<<chan)))
{
/* restore inputs update callback */
sprintf(msg, "PAD #%d is not connected !", chan+1);
GUI_WaitPrompt("Error",msg);
/* re-enable background PAD scanning and exit */
inputs_disabled = 0;
return;
}
/* Configure each keys */
do
{
/* ignore unused keys */
if (strcmp(keyname[first_key], "N.A"))
{
/* remove any pending keys */
while (PAD_ButtonsHeld(chan))
{
VIDEO_WaitVSync();
PAD_ScanPads();
}
/* configurable button */
sprintf(msg,"Press key for %s\n(D-PAD to return)",keyname[first_key]);
GUI_MsgBoxUpdate(0,msg);
/* wait for user input */
p = 0;
while (!p)
{
VIDEO_WaitVSync();
PAD_ScanPads();
p = PAD_ButtonsDown(chan);
}
/* find pressed key */
if (p & PAD_BUTTON_A) p = PAD_BUTTON_A;
else if (p & PAD_BUTTON_B) p = PAD_BUTTON_B;
else if (p & PAD_BUTTON_X) p = PAD_BUTTON_X;
else if (p & PAD_BUTTON_Y) p = PAD_BUTTON_Y;
else if (p & PAD_TRIGGER_R) p = PAD_TRIGGER_R;
else if (p & PAD_TRIGGER_L) p = PAD_TRIGGER_L;
else if (p & PAD_TRIGGER_Z) p = PAD_TRIGGER_Z;
else if (p & PAD_BUTTON_START) p = PAD_BUTTON_START;
else first_key = MAX_KEYS;
/* update key mapping */
if (first_key < MAX_KEYS)
{
config.pad_keymap[chan][first_key] = p;
}
}
}
while (first_key++ < last_key);
/* remove any pending keys */
while (PAD_ButtonsHeld(chan))
{
VIDEO_WaitVSync();
PAD_ScanPads();
}
/* Configurable menu key */
GUI_MsgBoxUpdate(0,"Press key(s) for MENU");
/* reset key combo */
config.pad_keymap[chan][KEY_MENU] = 0;
/* wait for user input */
p = 0;
while (!p)
{
/* update PAD status */
VIDEO_WaitVSync();
PAD_ScanPads();
p = PAD_ButtonsHeld(chan);
}
/* register keys until none are pressed anymore */
while (p)
{
/* update key combo */
config.pad_keymap[chan][KEY_MENU] |= p;
/* update PAD status */
VIDEO_WaitVSync();
PAD_ScanPads();
p = PAD_ButtonsHeld(chan);
}
/* re-enable background PAD scanning and exit */
inputs_disabled = 0;
}
static void pad_update(s8 chan, u8 i)
{
/* PAD status */
u16 p = PAD_ButtonsHeld(chan);
s8 x = PAD_StickX (chan);
s8 y = PAD_StickY (chan);
/* Retrieve current key mapping */
u16 *pad_keymap = config.pad_keymap[chan];
/* Default fast-forward key combo */
if ((p & PAD_TRIGGER_R) && (PAD_ButtonsDown(0) & PAD_BUTTON_START))
{
audioSync ^= AUDIO_WAIT;
videoSync = (audioSync && config.vsync && (gc_pal != vdp_pal)) ? VIDEO_WAIT : 0;
return;
}
/* User configurable menu combo */
if ((p & pad_keymap[KEY_MENU]) == pad_keymap[KEY_MENU])
{
ConfigRequested = 1;
return;
}
/* Default menu key (right analog stick if not needed by emulated device) */
if ((input.dev[i] < DEVICE_XE_1AP) && (PAD_SubStickX(chan) > ANALOG_SENSITIVITY))
{
ConfigRequested = 1;
return;
}
/* Emulated device */
switch (input.dev[i])
{
case DEVICE_PAD6B:
{
/* X,Y,Z,MODE buttons */
if (p & pad_keymap[KEY_BUTTONX]) input.pad[i] |= INPUT_X;
if (p & pad_keymap[KEY_BUTTONY]) input.pad[i] |= INPUT_Y;
if (p & pad_keymap[KEY_BUTTONZ]) input.pad[i] |= INPUT_Z;
if (p & pad_keymap[KEY_MODE]) input.pad[i] |= INPUT_MODE;
}
case DEVICE_PAD3B:
{
/* A button */
if (p & pad_keymap[KEY_BUTTONA]) input.pad[i] |= INPUT_A;
}
case DEVICE_PAD2B:
{
/* D-PAD */
if ((p & PAD_BUTTON_UP) || (y > ANALOG_SENSITIVITY)) input.pad[i] |= INPUT_UP;
else if ((p & PAD_BUTTON_DOWN) || (y < -ANALOG_SENSITIVITY)) input.pad[i] |= INPUT_DOWN;
if ((p & PAD_BUTTON_LEFT) || (x < -ANALOG_SENSITIVITY)) input.pad[i] |= INPUT_LEFT;
else if ((p & PAD_BUTTON_RIGHT) || (x > ANALOG_SENSITIVITY)) input.pad[i] |= INPUT_RIGHT;
/* default buttons */
if (p & pad_keymap[KEY_BUTTONB]) input.pad[i] |= INPUT_B;
if (p & pad_keymap[KEY_BUTTONC]) input.pad[i] |= INPUT_C;
if (p & pad_keymap[KEY_START]) input.pad[i] |= INPUT_START;
break;
}
case DEVICE_XE_1AP:
{
/* Left Stick analog position [0-255] */
input.analog[i][0] = (x + 128);
input.analog[i][1] = y ? (127 - y) : (128 - y);
/* Right Stick analog position [0-255] */
x = PAD_SubStickX(chan);
y = PAD_SubStickY(chan);
/* Emulated stick is unidirectional but can be rotated */
if (abs(x) > abs(y))
{
input.analog[i+1][0] = (x + 128);
}
else
{
input.analog[i+1][0] = (y + 128);
}
/* Buttons */
if (p & pad_keymap[KEY_BUTTONA]) input.pad[i] |= INPUT_XE_A;
if (p & pad_keymap[KEY_BUTTONB]) input.pad[i] |= INPUT_XE_B;
if (p & pad_keymap[KEY_BUTTONC]) input.pad[i] |= INPUT_XE_C;
if (p & pad_keymap[KEY_START]) input.pad[i] |= INPUT_XE_START;
if (p & pad_keymap[KEY_BUTTONX]) input.pad[i] |= INPUT_XE_D;
if (p & pad_keymap[KEY_BUTTONY]) input.pad[i] |= INPUT_XE_E1;
if (p & pad_keymap[KEY_BUTTONZ]) input.pad[i] |= INPUT_XE_E2;
if (p & pad_keymap[KEY_MODE]) input.pad[i] |= INPUT_XE_SELECT;
break;
}
case DEVICE_SPORTSPAD:
{
/* Y analog position [0-255] */
input.analog[i][1] = y ? (127 - y) : (128 - y);
}
case DEVICE_PADDLE:
{
/* X analog position [0-255] */
input.analog[i][0] = (x + 128);
/* Buttons */
if (p & pad_keymap[KEY_BUTTONB]) input.pad[i] |= INPUT_BUTTON1;
if (p & pad_keymap[KEY_BUTTONC]) input.pad[i] |= INPUT_BUTTON2;
if (p & pad_keymap[KEY_START]) input.pad[i] |= INPUT_START;
break;
}
case DEVICE_LIGHTGUN:
{
/* Gun screen position (x,y) */
input.analog[i][0] += x / ANALOG_SENSITIVITY;
input.analog[i][1] -= y / ANALOG_SENSITIVITY;
/* Limits */
if (input.analog[i][0] < 0) input.analog[i][0] = 0;
else if (input.analog[i][0] > bitmap.viewport.w) input.analog[i][0] = bitmap.viewport.w;
if (input.analog[i][1] < 0) input.analog[i][1] = 0;
else if (input.analog[i][1] > bitmap.viewport.h) input.analog[i][1] = bitmap.viewport.h;
/* Buttons */
if (p & pad_keymap[KEY_BUTTONA]) input.pad[i] |= INPUT_A;
if (p & pad_keymap[KEY_BUTTONB]) input.pad[i] |= INPUT_B;
if (p & pad_keymap[KEY_BUTTONC]) input.pad[i] |= INPUT_C;
if (p & pad_keymap[KEY_START]) input.pad[i] |= INPUT_START;
break;
}
case DEVICE_MOUSE:
{
/* Mouse relative movement (-255,255) */
input.analog[i][0] = (x / ANALOG_SENSITIVITY) * 2;
input.analog[i][1] = (y / ANALOG_SENSITIVITY) * 2;
/* Y-Axis inversion */
if (config.invert_mouse)
{
input.analog[i][1] = -input.analog[i][1];
}
/* Buttons */
if (p & pad_keymap[KEY_BUTTONA]) input.pad[i] |= INPUT_MOUSE_CENTER;
if (p & pad_keymap[KEY_BUTTONB]) input.pad[i] |= INPUT_MOUSE_LEFT;
if (p & pad_keymap[KEY_BUTTONC]) input.pad[i] |= INPUT_MOUSE_RIGHT;
if (p & pad_keymap[KEY_START]) input.pad[i] |= INPUT_START;
break;
}
case DEVICE_PICO:
{
/* D-PAD */
if (p & PAD_BUTTON_UP) input.pad[0] |= INPUT_UP;
else if (p & PAD_BUTTON_DOWN) input.pad[0] |= INPUT_DOWN;
if (p & PAD_BUTTON_LEFT) input.pad[0] |= INPUT_LEFT;
else if (p & PAD_BUTTON_RIGHT) input.pad[0] |= INPUT_RIGHT;
/* PEN screen position (x,y) */
input.analog[0][0] += x / ANALOG_SENSITIVITY;
input.analog[0][1] -= y / ANALOG_SENSITIVITY;
/* Limits */
if (input.analog[0][0] > 0x17c) input.analog[0][0] = 0x17c;
else if (input.analog[0][0] < 0x3c) input.analog[0][0] = 0x3c;
if (input.analog[0][1] < 0x1fc) input.analog[0][1] = 0x1fc;
else if (input.analog[0][1] > 0x2f7) input.analog[0][1] = 0x2f7;
/* PEN & RED button */
if (p & pad_keymap[KEY_BUTTONA]) input.pad[0] |= INPUT_PICO_RED;
if (p & pad_keymap[KEY_BUTTONB]) input.pad[0] |= INPUT_PICO_PEN;
/* PAGE index increment */
if (p & pad_keymap[KEY_BUTTONC]) pico_current = (pico_current + 1) & 7;
break;
}
case DEVICE_TEREBI:
{
/* PEN screen position (x,y) */
input.analog[0][0] += x / ANALOG_SENSITIVITY;
input.analog[0][1] -= y / ANALOG_SENSITIVITY;
/* Limits */
if (input.analog[0][0] < 0) input.analog[0][0] = 0;
else if (input.analog[0][0] > 250) input.analog[0][0] = 250;
if (input.analog[0][1] < 0) input.analog[0][1] = 0;
else if (input.analog[0][1] > 250) input.analog[0][1] = 250;
/* PEN button */
if (p & pad_keymap[KEY_BUTTONA]) input.pad[0] |= INPUT_BUTTON1;
break;
}
case DEVICE_GRAPHIC_BOARD:
{
/* PEN screen position (x,y) */
input.analog[0][0] += x / ANALOG_SENSITIVITY;
input.analog[0][1] -= y / ANALOG_SENSITIVITY;
/* Limits */
if (input.analog[0][0] < 0) input.analog[0][0] = 0;
else if (input.analog[0][0] > 255) input.analog[0][0] = 255;
if (input.analog[0][1] < 0) input.analog[0][1] = 0;
else if (input.analog[0][1] > 255) input.analog[0][1] = 255;
/* MODE buttons */
if (p & pad_keymap[KEY_BUTTONA]) input.pad[0] |= INPUT_GRAPHIC_PEN;
if (p & pad_keymap[KEY_BUTTONB]) input.pad[0] |= INPUT_GRAPHIC_DO;
if (p & pad_keymap[KEY_BUTTONC]) input.pad[0] |= INPUT_GRAPHIC_MENU;
break;
}
case DEVICE_ACTIVATOR:
{
/* Left & right analog stick angle [0-360] */
float ang;
/* Left stick values */
if ((abs(x) > ANALOG_SENSITIVITY) || (abs(y) > ANALOG_SENSITIVITY))
{
/* Calculate angle (in degree) */
ang = 90.0 - (atan((float)y / (float)x) * 180.0 / M_PI);
if (x < 0) ang += 180.0;
/* 8 bottom sensors = 8 areas */
if ((ang > 22.5) && (ang <= 67.5)) input.pad[i] |= INPUT_ACTIVATOR_2L;
else if ((ang > 67.5) && (ang <= 112.5)) input.pad[i] |= INPUT_ACTIVATOR_3L;
else if ((ang > 112.5) && (ang <= 157.5)) input.pad[i] |= INPUT_ACTIVATOR_4L;
else if ((ang > 157.5) && (ang <= 202.5)) input.pad[i] |= INPUT_ACTIVATOR_5L;
else if ((ang > 202.5) && (ang <= 247.5)) input.pad[i] |= INPUT_ACTIVATOR_6L;
else if ((ang > 247.5) && (ang <= 292.5)) input.pad[i] |= INPUT_ACTIVATOR_7L;
else if ((ang > 292.5) && (ang <= 337.5)) input.pad[i] |= INPUT_ACTIVATOR_8L;
else input.pad[i] |= INPUT_ACTIVATOR_1L;
}
/* Right stick values */
x = PAD_SubStickX(chan);
y = PAD_SubStickY(chan);
if ((abs(x) > ANALOG_SENSITIVITY) || (abs(y) > ANALOG_SENSITIVITY))
{
/* Calculate angle (in degree) */
ang = 90.0 - (atan((float)y / (float)x) * 180.0 / M_PI);
if (x < 0) ang += 180.0;
/* 8 top sensors = 8 areas */
if ((ang > 22.5) && (ang <= 67.5)) input.pad[i] |= INPUT_ACTIVATOR_2U;
else if ((ang > 67.5) && (ang <= 112.5)) input.pad[i] |= INPUT_ACTIVATOR_3U;
else if ((ang > 112.5) && (ang <= 157.5)) input.pad[i] |= INPUT_ACTIVATOR_4U;
else if ((ang > 157.5) && (ang <= 202.5)) input.pad[i] |= INPUT_ACTIVATOR_5U;
else if ((ang > 202.5) && (ang <= 247.5)) input.pad[i] |= INPUT_ACTIVATOR_6U;
else if ((ang > 247.5) && (ang <= 292.5)) input.pad[i] |= INPUT_ACTIVATOR_7U;
else if ((ang > 292.5) && (ang <= 337.5)) input.pad[i] |= INPUT_ACTIVATOR_8U;
else input.pad[i] |= INPUT_ACTIVATOR_1U;
}
break;
}
}
}
/***************************************************************************************/
/* Wii WPAD support */
/***************************************************************************************/
#ifdef HW_RVL
static int wpad_StickX(WPADData *data, u8 right)
{
struct joystick_t* js = NULL;
switch (data->exp.type)
{
case WPAD_EXP_NUNCHUK:
js = right ? NULL : &data->exp.nunchuk.js;
break;
case WPAD_EXP_CLASSIC:
js = right ? &data->exp.classic.rjs : &data->exp.classic.ljs;
break;
default:
break;
}
if (js)
{
/* raw X position */
int pos = js->pos.x;
/* X range calibration */
int min = js->min.x;
int max = js->max.x;
int center = js->center.x;
/* some 3rd party controllers return invalid analog sticks calibration data */
if ((min >= center) || (max <= center))
{
/* force default calibration settings */
min = js->min.x = 0;
max = js->max.x = right ? 32 : 64;
center = js->center.x = right ? 16 : 32;
}
/* value returned could be above calibration limits */
if (pos > max) return 127;
if (pos < min) return -128;
/* adjust against center position */
pos -= center;
/* return interpolated range [-128;127] */
if (pos > 0)
{
return (int)(127.0 * ((float)pos / (float)(max - center)));
}
else
{
return (int)(128.0 * ((float)pos / (float)(center - min)));
}
}
return 0;
}
static int wpad_StickY(WPADData *data, u8 right)
{
struct joystick_t* js = NULL;
switch (data->exp.type)
{
case WPAD_EXP_NUNCHUK:
js = right ? NULL : &data->exp.nunchuk.js;
break;
case WPAD_EXP_CLASSIC:
js = right ? &data->exp.classic.rjs : &data->exp.classic.ljs;
break;
default:
break;
}
if (js)
{
/* raw Y position */
int pos = js->pos.y;
/* Y range calibration */
int min = js->min.y;
int max = js->max.y;
int center = js->center.y;
/* some 3rd party controllers return invalid analog sticks calibration data */
if ((min >= center) || (max <= center))
{
/* force default calibration settings */
min = js->min.y = 0;
max = js->max.y = right ? 32 : 64;
center = js->center.y = right ? 16 : 32;
}
/* value returned could be above calibration limits */
if (pos > max) return 127;
if (pos < min) return -128;
/* adjust against center position */
pos -= center;
/* return interpolated range [-128;127] */
if (pos > 0)
{
return (int)(127.0 * ((float)pos / (float)(max - center)));
}
else
{
return (int)(128.0 * ((float)pos / (float)(center - min)));
}
}
return 0;
}
static void wpad_config(u8 exp, int chan, int first_key, int last_key)
{
char msg[64];
u32 p = 255;
/* Disable background PAD scanning */
inputs_disabled = 1;
/* Check if device is connected */
if (exp <= WPAD_EXP_CLASSIC)
{
WPAD_Probe(chan, &p);
}
else
{
if (WiiDRC_Inited() && WiiDRC_Connected())
{
p = exp;
}
}
/* Device not detected */
if (((exp > WPAD_EXP_NONE) && (p != exp)) || (p == 255))
{
if (exp == WPAD_EXP_NONE) sprintf(msg, "WIIMOTE #%d is not connected !", chan+1);
else if (exp == WPAD_EXP_NUNCHUK) sprintf(msg, "NUNCHUK #%d is not connected !", chan+1);
else if (exp == WPAD_EXP_CLASSIC) sprintf(msg, "CLASSIC #%d is not connected !", chan+1);
else sprintf(msg, "WIIU GAMEPAD is not connected !");
GUI_WaitPrompt("Error",msg);
/* re-enable background PAD scanning and exit */
inputs_disabled = 0;
return;
}
/* Configure each keys */
do
{
/* ignore unused keys */
if (strcmp(keyname[first_key], "N.A"))
{
/* remove any pending buttons */
if (exp <= WPAD_EXP_CLASSIC)
{
while (WPAD_ButtonsHeld(chan))
{
VIDEO_WaitVSync();
WPAD_ScanPads();
}
}
else
{
while (WiiDRC_ButtonsHeld())
{
VIDEO_WaitVSync();
WiiDRC_ScanPads();
}
}
/* configurable button */
sprintf(msg,"Press key for %s\n(HOME to return)",keyname[first_key]);
GUI_MsgBoxUpdate(0,msg);
/* wait for user input */
p = 0;
while (!p)
{
VIDEO_WaitVSync();
if (exp <= WPAD_EXP_CLASSIC)
{
WPAD_ScanPads();
p = WPAD_ButtonsDown(chan);
}
else
{
WiiDRC_ScanPads();
p = WiiDRC_ButtonsDown();
}
}
/* detect pressed key */
switch (exp)
{
/* Wiimote (TODO: add motion sensing !) */
case WPAD_EXP_NONE:
{
if (p & WPAD_BUTTON_2) p = WPAD_BUTTON_2;
else if (p & WPAD_BUTTON_1) p = WPAD_BUTTON_1;
else if (p & WPAD_BUTTON_B) p = WPAD_BUTTON_B;
else if (p & WPAD_BUTTON_A) p = WPAD_BUTTON_A;
else if (p & WPAD_BUTTON_PLUS) p = WPAD_BUTTON_PLUS;
else if (p & WPAD_BUTTON_MINUS) p = WPAD_BUTTON_MINUS;
else first_key = MAX_KEYS;
break;
}
/* Wiimote + Nunchuk (TODO: add motion sensing !) */
case WPAD_EXP_NUNCHUK:
{
if (p & WPAD_BUTTON_2) p = WPAD_BUTTON_2;
else if (p & WPAD_BUTTON_1) p = WPAD_BUTTON_1;
else if (p & WPAD_BUTTON_B) p = WPAD_BUTTON_B;
else if (p & WPAD_BUTTON_A) p = WPAD_BUTTON_A;
else if (p & WPAD_BUTTON_PLUS) p = WPAD_BUTTON_PLUS;
else if (p & WPAD_BUTTON_MINUS) p= WPAD_BUTTON_MINUS;
else if (p & WPAD_NUNCHUK_BUTTON_Z) p = WPAD_NUNCHUK_BUTTON_Z;
else if (p & WPAD_NUNCHUK_BUTTON_C) p = WPAD_NUNCHUK_BUTTON_C;
else first_key = MAX_KEYS;
break;
}
/* Classic Controller */
case WPAD_EXP_CLASSIC:
{
if (p & WPAD_CLASSIC_BUTTON_X) p = WPAD_CLASSIC_BUTTON_X;
else if (p & WPAD_CLASSIC_BUTTON_A) p = WPAD_CLASSIC_BUTTON_A;
else if (p & WPAD_CLASSIC_BUTTON_Y) p = WPAD_CLASSIC_BUTTON_Y;
else if (p & WPAD_CLASSIC_BUTTON_B) p = WPAD_CLASSIC_BUTTON_B;
else if (p & WPAD_CLASSIC_BUTTON_ZL) p = WPAD_CLASSIC_BUTTON_ZL;
else if (p & WPAD_CLASSIC_BUTTON_ZR) p = WPAD_CLASSIC_BUTTON_ZR;
else if (p & WPAD_CLASSIC_BUTTON_PLUS) p = WPAD_CLASSIC_BUTTON_PLUS;
else if (p & WPAD_CLASSIC_BUTTON_MINUS) p = WPAD_CLASSIC_BUTTON_MINUS;
else if (p & WPAD_CLASSIC_BUTTON_FULL_L) p = WPAD_CLASSIC_BUTTON_FULL_L;
else if (p & WPAD_CLASSIC_BUTTON_FULL_R) p = WPAD_CLASSIC_BUTTON_FULL_R;
else first_key = MAX_KEYS;
break;
}
/* WiiU GamePad Controller */
default:
{
if (p & WIIDRC_BUTTON_A) p = WIIDRC_BUTTON_A;
else if (p & WIIDRC_BUTTON_B) p = WIIDRC_BUTTON_B;
else if (p & WIIDRC_BUTTON_X) p = WIIDRC_BUTTON_X;
else if (p & WIIDRC_BUTTON_Y) p = WIIDRC_BUTTON_Y;
else if (p & WIIDRC_BUTTON_ZL) p = WIIDRC_BUTTON_ZL;
else if (p & WIIDRC_BUTTON_ZR) p = WIIDRC_BUTTON_ZR;
else if (p & WIIDRC_BUTTON_PLUS) p = WIIDRC_BUTTON_PLUS;
else if (p & WIIDRC_BUTTON_MINUS) p = WIIDRC_BUTTON_MINUS;
else if (p & WIIDRC_BUTTON_L) p = WIIDRC_BUTTON_L;
else if (p & WIIDRC_BUTTON_R) p = WIIDRC_BUTTON_R;
else first_key = MAX_KEYS;
break;
}
}
/* update key mapping */
if (first_key < MAX_KEYS)
{
config.wpad_keymap[4*exp + chan][first_key] = p;
}
}
}
while (first_key++ < last_key);
/* remove any pending buttons */
if (exp <= WPAD_EXP_CLASSIC)
{
while (WPAD_ButtonsHeld(chan))
{
VIDEO_WaitVSync();
WPAD_ScanPads();
}
}
else
{
while (WiiDRC_ButtonsHeld())
{
VIDEO_WaitVSync();
WiiDRC_ScanPads();
}
}
/* Configurable menu key */
GUI_MsgBoxUpdate(0,"Press key(s) for MENU");
/* reset key combo */
config.wpad_keymap[4*exp + chan][KEY_MENU] = 0;
/* wait for user input */
p = 0;
while (!p)
{
VIDEO_WaitVSync();
if (exp <= WPAD_EXP_CLASSIC)
{
WPAD_ScanPads();
p = WPAD_ButtonsHeld(chan);
}
else
{
WiiDRC_ScanPads();
p = WiiDRC_ButtonsHeld();
}
}
/* register keys until none are pressed anymore */
while (p)
{
/* update key combo */
config.wpad_keymap[4*exp + chan][KEY_MENU] |= p;
/* update WPAD status */
VIDEO_WaitVSync();
if (exp <= WPAD_EXP_CLASSIC)
{
WPAD_ScanPads();
p = WPAD_ButtonsHeld(chan);
}
else
{
WiiDRC_ScanPads();
p = WiiDRC_ButtonsHeld();
}
}
/* re-enable background WPAD scanning and exit */
inputs_disabled = 0;
}
static void wpad_update(s8 chan, u8 i, u32 exp)
{
/* WPAD data */
WPADData *data = WPAD_Data(chan);
/* Button status */
u32 p = data->btns_h;
/* Analog sticks */
s16 x = 0;
s16 y = 0;
/* WiiU GamePad Controller support */
if (exp > WPAD_EXP_CLASSIC)
{
WiiDRC_ScanPads();
if (WiiDRC_ShutdownRequested())
{
Shutdown = ConfigRequested = 1;
reload = 0;
return;
}
p = WiiDRC_ButtonsHeld();
/* Default fast-forward key combo */
if (WiiDRC_ButtonsDown() & WIIDRC_BUTTON_HOME)
{
if (p & WIIDRC_BUTTON_MINUS)
{
audioSync ^= AUDIO_WAIT;
videoSync = (audioSync && config.vsync && (gc_pal != vdp_pal)) ? VIDEO_WAIT : 0;
return;
}
}
/* Left Analog Stick */
x = (WiiDRC_lStickX() * 128) / 75;
y = (WiiDRC_lStickY() * 128) / 75;
if (x > 127) x = 127;
else if (x < -128) x = -128;
if (y > 127) y = 127;
else if (y < -128) y = -128;
}
else if (exp != WPAD_EXP_NONE)
{
/* Left Analog Stick */
x = wpad_StickX(data,0);
y = wpad_StickY(data,0);
}
/* Retrieve current key mapping */
u32 *wpad_keymap = config.wpad_keymap[4*exp + chan];
/* User configurable menu combo */
if ((p & wpad_keymap[KEY_MENU]) == wpad_keymap[KEY_MENU])
{
ConfigRequested = 1;
return;
}
/* Emulated device */
switch (input.dev[i])
{
case DEVICE_PAD6B:
{
/* X,Y,Z,MODE buttons */
if (p & wpad_keymap[KEY_BUTTONX]) input.pad[i] |= INPUT_X;
if (p & wpad_keymap[KEY_BUTTONY]) input.pad[i] |= INPUT_Y;
if (p & wpad_keymap[KEY_BUTTONZ]) input.pad[i] |= INPUT_Z;
if (p & wpad_keymap[KEY_MODE]) input.pad[i] |= INPUT_MODE;
}
case DEVICE_PAD3B:
{
/* A button */
if (p & wpad_keymap[KEY_BUTTONA]) input.pad[i] |= INPUT_A;
}
case DEVICE_PAD2B:
{
/* D-PAD */
if ((p & wpad_dirmap[exp][PAD_UP]) || (y > ANALOG_SENSITIVITY)) input.pad[i] |= INPUT_UP;
else if ((p & wpad_dirmap[exp][PAD_DOWN]) || (y < -ANALOG_SENSITIVITY)) input.pad[i] |= INPUT_DOWN;
if ((p & wpad_dirmap[exp][PAD_LEFT]) || (x < -ANALOG_SENSITIVITY)) input.pad[i] |= INPUT_LEFT;
else if ((p & wpad_dirmap[exp][PAD_RIGHT]) || (x > ANALOG_SENSITIVITY)) input.pad[i] |= INPUT_RIGHT;
/* default buttons */
if (p & wpad_keymap[KEY_BUTTONB]) input.pad[i] |= INPUT_B;
if (p & wpad_keymap[KEY_BUTTONC]) input.pad[i] |= INPUT_C;
if (p & wpad_keymap[KEY_START]) input.pad[i] |= INPUT_START;
break;
}
case DEVICE_XE_1AP:
{
/* Left Stick analog position [0-255] */
input.analog[i][0] = (x + 128);
input.analog[i][1] = y ? (127 - y) : 128;
/* Right Stick analog position [0-255] */
if (exp >= WPAD_EXP_CLASSIC)
{
if (exp > WPAD_EXP_CLASSIC)
{
/* WiiU GamePad Controller right stick */
x = (WiiDRC_rStickX() * 128) / 75;
y = (WiiDRC_rStickY() * 128) / 75;
if (x > 127) x = 127;
else if (x < -128) x = -128;
if (y > 127) y = 127;
else if (y < -128) y = -128;
}
else
{
/* Classic Controller right stick */
x = wpad_StickX(data,1);
y = wpad_StickY(data,1);
}
/* Emulated stick is unidirectional but can be rotated */
if (abs(x) > abs(y))
{
input.analog[i+1][0] = (x + 128);
}
else
{
input.analog[i+1][0] = (y + 128);
}
}
else
{
/* Wiimote D-PAD */
if ((p & wpad_dirmap[exp][PAD_DOWN]) || (p & wpad_dirmap[exp][PAD_LEFT])) input.analog[i+1][0]-=2;
else if ((p & wpad_dirmap[exp][PAD_UP]) || (p & wpad_dirmap[exp][PAD_RIGHT])) input.analog[i+1][0]+=2;
/* Limits */
if (input.analog[i+1][0] < 0) input.analog[i+1][0] = 0;
else if (input.analog[i+1][0] > 255) input.analog[i+1][0] = 255;
}
/* Buttons */
if (p & wpad_keymap[KEY_BUTTONA]) input.pad[i] |= INPUT_XE_A;
if (p & wpad_keymap[KEY_BUTTONB]) input.pad[i] |= INPUT_XE_B;
if (p & wpad_keymap[KEY_BUTTONC]) input.pad[i] |= INPUT_XE_C;
if (p & wpad_keymap[KEY_START]) input.pad[i] |= INPUT_XE_START;
if (p & wpad_keymap[KEY_BUTTONX]) input.pad[i] |= INPUT_XE_D;
if (p & wpad_keymap[KEY_BUTTONY]) input.pad[i] |= INPUT_XE_E1;
if (p & wpad_keymap[KEY_BUTTONZ]) input.pad[i] |= INPUT_XE_E2;
if (p & wpad_keymap[KEY_MODE]) input.pad[i] |= INPUT_XE_SELECT;
break;
}
case DEVICE_SPORTSPAD:
{
/* X analog position [0-255] */
if (p & wpad_dirmap[exp][PAD_LEFT]) input.analog[i][0]-=2;
else if (p & wpad_dirmap[exp][PAD_RIGHT]) input.analog[i][0]+=2;
else input.analog[i][0] = (x + 128);
/* Y analog position [0-255] */
if (p & wpad_dirmap[exp][PAD_UP]) input.analog[i][1]-=2;
else if (p & wpad_dirmap[exp][PAD_DOWN]) input.analog[i][1]+=2;
else input.analog[i][1] = y ? (127 - y) : (128 - y);
/* Limits */
if (input.analog[i][0] < 0) input.analog[i][0] = 0;
else if (input.analog[i][0] > 255) input.analog[i][0] = 255;
if (input.analog[i][1] < 0) input.analog[i][1] = 0;
else if (input.analog[i][1] > 255) input.analog[i][1] = 255;
/* Buttons */
if (p & wpad_keymap[KEY_BUTTONB]) input.pad[i] |= INPUT_BUTTON1;
if (p & wpad_keymap[KEY_BUTTONC]) input.pad[i] |= INPUT_BUTTON2;
if (p & wpad_keymap[KEY_START]) input.pad[i] |= INPUT_START;
break;
}
case DEVICE_PADDLE:
{
/* X analog position [0-255] */
if (exp == WPAD_EXP_NONE)
{
/* Wiimote D-PAD */
if (p & wpad_dirmap[exp][PAD_LEFT]) input.analog[i][0]-=2;
else if (p & wpad_dirmap[exp][PAD_RIGHT]) input.analog[i][0]+=2;
/* Limits */
if (input.analog[i][0] < 0) input.analog[i][0] = 0;
else if (input.analog[i][0] > 255) input.analog[i][0] = 255;
}
else
{
/* Left analog stick */
input.analog[i][0] = (x + 128);
}
/* Buttons */
if (p & wpad_keymap[KEY_BUTTONB]) input.pad[i] |= INPUT_BUTTON1;
if (p & wpad_keymap[KEY_START]) input.pad[i] |= INPUT_START;
break;
}
case DEVICE_LIGHTGUN:
{
/* Gun screen position (x,y) */
if (exp < WPAD_EXP_CLASSIC)
{
/* Wiimote IR */
struct ir_t ir;
WPAD_IR(chan, &ir);
if (ir.valid)
{
/* screen position */
input.analog[i][0] = ((ir.x + config.calx) * bitmap.viewport.w) / 640;
input.analog[i][1] = ((ir.y + config.caly) * bitmap.viewport.h) / 480;
}
else
{
/* lightgun should point outside screen area */
input.analog[i][0] = 512;
input.analog[i][1] = 512;
}
}
else
{
/* Left analog stick */
input.analog[i][0] += x / ANALOG_SENSITIVITY;
input.analog[i][1] -= y / ANALOG_SENSITIVITY;
/* Limits */
if (input.analog[i][0] < 0) input.analog[i][0] = 0;
else if (input.analog[i][0] > bitmap.viewport.w) input.analog[i][0] = bitmap.viewport.w;
if (input.analog[i][1] < 0) input.analog[i][1] = 0;
else if (input.analog[i][1] > bitmap.viewport.h) input.analog[i][1] = bitmap.viewport.h;
}
/* Buttons */
if (p & wpad_keymap[KEY_BUTTONA]) input.pad[i] |= INPUT_A;
if (p & wpad_keymap[KEY_BUTTONB]) input.pad[i] |= INPUT_B;
if (p & wpad_keymap[KEY_BUTTONC]) input.pad[i] |= INPUT_C;
if (p & wpad_keymap[KEY_START]) input.pad[i] |= INPUT_START;
break;
}
case DEVICE_MOUSE:
{
/* Mouse relative movement (-255,255) */
if (MOUSE_IsConnected())
{
/* USB mouse support */
mouse_event event;
MOUSE_GetEvent(&event);
MOUSE_FlushEvents();
/* USB mouse position (-127;+127) -> (-255;+255) */
input.analog[i][0] = event.rx * 2;
input.analog[i][1] = event.ry * 2;
/* USB mouse buttons */
if (event.button & 1) input.pad[i] |= INPUT_MOUSE_RIGHT;
if (event.button & 2) input.pad[i] |= INPUT_MOUSE_CENTER;
if (event.button & 4) input.pad[i] |= INPUT_MOUSE_LEFT;
}
else if (exp == WPAD_EXP_NONE)
{
/* Wiimote IR (buggy) */
struct ir_t ir;
WPAD_IR(chan, &ir);
/* Only if Wiimote is pointed to screen */
if(ir.smooth_valid)
{
input.analog[i][0] = (int)((ir.sx - 512) / 2 / ANALOG_SENSITIVITY);
input.analog[i][1] = (int)((ir.sy - 384) * 2 / 3 / ANALOG_SENSITIVITY);
}
}
else
{
/* Left analog stick position (-127;+127) -> (-255;+255) */
input.analog[i][0] = (x / ANALOG_SENSITIVITY) * 2;
input.analog[i][1] = (y / ANALOG_SENSITIVITY) * 2;
}
/* Y-Axis inversion */
if (config.invert_mouse)
{
input.analog[i][1] = -input.analog[i][1];
}
/* Buttons */
if (p & wpad_keymap[KEY_BUTTONA]) input.pad[i] |= INPUT_MOUSE_CENTER;
if (p & wpad_keymap[KEY_BUTTONB]) input.pad[i] |= INPUT_MOUSE_LEFT;
if (p & wpad_keymap[KEY_BUTTONC]) input.pad[i] |= INPUT_MOUSE_RIGHT;
if (p & wpad_keymap[KEY_START]) input.pad[i] |= INPUT_START;
break;
}
case DEVICE_PICO:
{
/* D-PAD */
if (p & PAD_BUTTON_UP) input.pad[i] |= INPUT_UP;
else if (p & PAD_BUTTON_DOWN) input.pad[i] |= INPUT_DOWN;
if (p & PAD_BUTTON_LEFT) input.pad[i] |= INPUT_LEFT;
else if (p & PAD_BUTTON_RIGHT) input.pad[i] |= INPUT_RIGHT;
/* PEN screen position (x,y) */
if (exp < WPAD_EXP_CLASSIC)
{
/* Wiimote IR */
struct ir_t ir;
WPAD_IR(chan, &ir);
if (ir.valid)
{
input.analog[0][0] = 0x3c + ((ir.x + config.calx) * (0x17c - 0x3c + 1)) / 640;
input.analog[0][1] = 0x1fc + ((ir.y + config.caly) * (0x2f7 - 0x1fc + 1)) / 480;
}
}
else
{
/* Left analog stick */
input.analog[0][0] += x / ANALOG_SENSITIVITY;
input.analog[0][1] -= y / ANALOG_SENSITIVITY;
/* Limits */
if (input.analog[0][0] > 0x17c) input.analog[0][0] = 0x17c;
else if (input.analog[0][0] < 0x3c) input.analog[0][0] = 0x3c;
if (input.analog[0][1] < 0x1fc) input.analog[0][1] = 0x1fc;
else if (input.analog[0][1] > 0x2f7) input.analog[0][1] = 0x2f7;
}
/* PEN & RED buttons */
if (p & wpad_keymap[KEY_BUTTONA]) input.pad[0] |= INPUT_PICO_PEN;
if (p & wpad_keymap[KEY_BUTTONB]) input.pad[0] |= INPUT_PICO_RED;
/* PAGE index increment */
if (p & wpad_keymap[KEY_BUTTONC]) pico_current = (pico_current + 1) & 7;
break;
}
case DEVICE_TEREBI:
{
/* PEN screen position (x,y) */
if (exp < WPAD_EXP_CLASSIC)
{
/* Wiimote IR */
struct ir_t ir;
WPAD_IR(chan, &ir);
if (ir.valid)
{
input.analog[0][0] = ((ir.x + config.calx) * 250) / 640;
input.analog[0][1] = ((ir.y + config.caly) * 250) / 480;
}
}
else
{
/* Left analog stick */
input.analog[0][0] += x / ANALOG_SENSITIVITY;
input.analog[0][1] -= y / ANALOG_SENSITIVITY;
/* Limits */
if (input.analog[0][0] < 0)input.analog[0][0] = 0;
else if (input.analog[0][0] > 250) input.analog[0][0] = 250;
if (input.analog[0][1] < 0) input.analog[0][1] = 0;
else if (input.analog[0][1] > 250) input.analog[0][1] = 250;
}
/* PEN button */
if (p & wpad_keymap[KEY_BUTTONA]) input.pad[0] |= INPUT_BUTTON1;
break;
}
case DEVICE_GRAPHIC_BOARD:
{
/* PEN screen position (x,y) */
if (exp < WPAD_EXP_CLASSIC)
{
/* Wiimote IR */
struct ir_t ir;
WPAD_IR(chan, &ir);
if (ir.valid)
{
input.analog[0][0] = ((ir.x + config.calx) * 255) / 640;
input.analog[0][1] = ((ir.y + config.caly) * 255) / 480;
}
}
else
{
/* Left analog stick */
input.analog[0][0] += x / ANALOG_SENSITIVITY;
input.analog[0][1] -= y / ANALOG_SENSITIVITY;
/* Limits */
if (input.analog[0][0] < 0)input.analog[0][0] = 0;
else if (input.analog[0][0] > 255) input.analog[0][0] = 255;
if (input.analog[0][1] < 0) input.analog[0][1] = 0;
else if (input.analog[0][1] > 255) input.analog[0][1] = 255;
}
/* MODE Buttons */
if (p & wpad_keymap[KEY_BUTTONA]) input.pad[0] |= INPUT_GRAPHIC_PEN;
if (p & wpad_keymap[KEY_BUTTONB]) input.pad[0] |= INPUT_GRAPHIC_DO;
if (p & wpad_keymap[KEY_BUTTONC]) input.pad[0] |= INPUT_GRAPHIC_MENU;
break;
}
case DEVICE_ACTIVATOR:
{
/* Classic Controller only */
if (exp == WPAD_EXP_CLASSIC)
{
/* Left stick */
float mag = data->exp.classic.ljs.mag;
float ang = data->exp.classic.ljs.ang;
if (mag > 0.5)
{
/* 8 bottom sensors = 8 areas */
if ((ang > 22.5) && (ang <= 67.5)) input.pad[i] |= INPUT_ACTIVATOR_2L;
else if ((ang > 67.5) && (ang <= 112.5)) input.pad[i] |= INPUT_ACTIVATOR_3L;
else if ((ang > 112.5) && (ang <= 157.5)) input.pad[i] |= INPUT_ACTIVATOR_4L;
else if ((ang > 157.5) && (ang <= 202.5)) input.pad[i] |= INPUT_ACTIVATOR_5L;
else if ((ang > 202.5) && (ang <= 247.5)) input.pad[i] |= INPUT_ACTIVATOR_6L;
else if ((ang > 247.5) && (ang <= 292.5)) input.pad[i] |= INPUT_ACTIVATOR_7L;
else if ((ang > 292.5) && (ang <= 337.5)) input.pad[i] |= INPUT_ACTIVATOR_8L;
else input.pad[i] |= INPUT_ACTIVATOR_1L;
}
/* Right stick */
mag = data->exp.classic.rjs.mag;
ang = data->exp.classic.rjs.ang;
if (mag > 0.5)
{
/* 8 top sensors = 8 areas */
if ((ang > 22.5) && (ang <= 67.5)) input.pad[i] |= INPUT_ACTIVATOR_2U;
else if ((ang > 67.5) && (ang <= 112.5)) input.pad[i] |= INPUT_ACTIVATOR_3U;
else if ((ang > 112.5) && (ang <= 157.5)) input.pad[i] |= INPUT_ACTIVATOR_4U;
else if ((ang > 157.5) && (ang <= 202.5)) input.pad[i] |= INPUT_ACTIVATOR_5U;
else if ((ang > 202.5) && (ang <= 247.5)) input.pad[i] |= INPUT_ACTIVATOR_6U;
else if ((ang > 247.5) && (ang <= 292.5)) input.pad[i] |= INPUT_ACTIVATOR_7U;
else if ((ang > 292.5) && (ang <= 337.5)) input.pad[i] |= INPUT_ACTIVATOR_8U;
else input.pad[i] |= INPUT_ACTIVATOR_1U;
}
}
break;
}
}
}
#endif
/***************************************************************************************/
/* GX Input interface */
/***************************************************************************************/
void gx_input_Init(void)
{
PAD_Init();
#ifdef HW_RVL
WPAD_Init();
WPAD_SetDataFormat(WPAD_CHAN_ALL,WPAD_FMT_BTNS_ACC_IR);
WPAD_SetVRes(WPAD_CHAN_ALL,640,480);
WiiDRC_Init();
#endif
}
int gx_input_FindDevices(void)
{
int i;
#ifdef HW_RVL
u32 wpad;
#endif
int found = 0;
int player = 0;
VIDEO_WaitVSync();
u32 pad = PAD_ScanPads();
for (i=0; i<MAX_DEVICES; i++)
{
/* check emulated peripheral */
if (input.dev[i] != NO_DEVICE)
{
/* test input device */
switch (config.input[player].device)
{
case 0: /* Gamecube Controller */
{
if (pad & (1 << config.input[player].port))
{
found++;
}
break;
}
#ifdef HW_RVL
case 1: /* Wiimote */
{
wpad = 255;
WPAD_Probe(config.input[player].port, &wpad);
/* make sure this is not a Wii U Pro Controller */
if (wpad == WPAD_EXP_CLASSIC)
{
WPADData *data = WPAD_Data(config.input[player].port);
if (data->exp.classic.type != 2)
{
found++;
}
}
else if (wpad != 255)
{
found++;
}
break;
}
case 2: /* Expansion Controller */
case 3:
{
wpad = 255;
WPAD_Probe(config.input[player].port, &wpad);
if (wpad == (config.input[player].device - 1))
{
found++;
}
break;
}
case 4: /* WiiU GamePad Controller */
{
if (WiiDRC_Inited() && WiiDRC_Connected())
{
found++;
}
break;
}
#endif
default:
{
break;
}
}
/* next configured player */
player ++;
}
}
/* return number of connected devices */
return found;
}
void gx_input_SetDefault(void)
{
int i,j;
u32 exp;
/* 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_BUTTONX] = PAD_TRIGGER_L;
config.pad_keymap[i][KEY_BUTTONY] = PAD_BUTTON_Y;
config.pad_keymap[i][KEY_BUTTONZ] = PAD_TRIGGER_R;
config.pad_keymap[i][KEY_MODE] = PAD_TRIGGER_Z;
config.pad_keymap[i][KEY_MENU] = PAD_TRIGGER_Z | PAD_BUTTON_RIGHT;
}
#ifdef HW_RVL
for (i=0; i<4; i++)
{
/* Wiimote (horizontal) */
config.wpad_keymap[4*WPAD_EXP_NONE + i][KEY_BUTTONA] = WPAD_BUTTON_A;
config.wpad_keymap[4*WPAD_EXP_NONE + i][KEY_BUTTONB] = WPAD_BUTTON_1;
config.wpad_keymap[4*WPAD_EXP_NONE + i][KEY_BUTTONC] = WPAD_BUTTON_2;
config.wpad_keymap[4*WPAD_EXP_NONE + i][KEY_START] = WPAD_BUTTON_PLUS;
config.wpad_keymap[4*WPAD_EXP_NONE + i][KEY_BUTTONX] = 0;
config.wpad_keymap[4*WPAD_EXP_NONE + i][KEY_BUTTONY] = 0;
config.wpad_keymap[4*WPAD_EXP_NONE + i][KEY_BUTTONZ] = 0;
config.wpad_keymap[4*WPAD_EXP_NONE + i][KEY_MODE] = 0;
config.wpad_keymap[4*WPAD_EXP_NONE + i][KEY_MENU] = WPAD_BUTTON_HOME;
/* Wiimote + Nunchuk */
config.wpad_keymap[4*WPAD_EXP_NUNCHUK + i][KEY_BUTTONA] = WPAD_NUNCHUK_BUTTON_Z;
config.wpad_keymap[4*WPAD_EXP_NUNCHUK + i][KEY_BUTTONB] = WPAD_BUTTON_B;
config.wpad_keymap[4*WPAD_EXP_NUNCHUK + i][KEY_BUTTONC] = WPAD_BUTTON_A;
config.wpad_keymap[4*WPAD_EXP_NUNCHUK + i][KEY_START] = WPAD_BUTTON_PLUS;
config.wpad_keymap[4*WPAD_EXP_NUNCHUK + i][KEY_BUTTONX] = WPAD_NUNCHUK_BUTTON_C;
config.wpad_keymap[4*WPAD_EXP_NUNCHUK + i][KEY_BUTTONY] = WPAD_BUTTON_1;
config.wpad_keymap[4*WPAD_EXP_NUNCHUK + i][KEY_BUTTONZ] = WPAD_BUTTON_2;
config.wpad_keymap[4*WPAD_EXP_NUNCHUK + i][KEY_MODE] = WPAD_BUTTON_MINUS;
config.wpad_keymap[4*WPAD_EXP_NUNCHUK + i][KEY_MENU] = WPAD_BUTTON_HOME;
/* Classic Controller */
config.wpad_keymap[4*WPAD_EXP_CLASSIC + i][KEY_BUTTONA] = WPAD_CLASSIC_BUTTON_Y;
config.wpad_keymap[4*WPAD_EXP_CLASSIC + i][KEY_BUTTONB] = WPAD_CLASSIC_BUTTON_B;
config.wpad_keymap[4*WPAD_EXP_CLASSIC + i][KEY_BUTTONC] = WPAD_CLASSIC_BUTTON_A;
config.wpad_keymap[4*WPAD_EXP_CLASSIC + i][KEY_START] = WPAD_CLASSIC_BUTTON_PLUS;
config.wpad_keymap[4*WPAD_EXP_CLASSIC + i][KEY_BUTTONX] = WPAD_CLASSIC_BUTTON_ZL;
config.wpad_keymap[4*WPAD_EXP_CLASSIC + i][KEY_BUTTONY] = WPAD_CLASSIC_BUTTON_ZR;
config.wpad_keymap[4*WPAD_EXP_CLASSIC + i][KEY_BUTTONZ] = WPAD_CLASSIC_BUTTON_X;
config.wpad_keymap[4*WPAD_EXP_CLASSIC + i][KEY_MODE] = WPAD_CLASSIC_BUTTON_MINUS;
config.wpad_keymap[4*WPAD_EXP_CLASSIC + i][KEY_MENU] = WPAD_CLASSIC_BUTTON_HOME;
/* WiiU GamePad Controller */
config.wpad_keymap[4*3][KEY_BUTTONA] = WIIDRC_BUTTON_Y;
config.wpad_keymap[4*3][KEY_BUTTONB] = WIIDRC_BUTTON_B;
config.wpad_keymap[4*3][KEY_BUTTONC] = WIIDRC_BUTTON_A;
config.wpad_keymap[4*3][KEY_START] = WIIDRC_BUTTON_PLUS;
config.wpad_keymap[4*3][KEY_BUTTONX] = WIIDRC_BUTTON_L;
config.wpad_keymap[4*3][KEY_BUTTONY] = WIIDRC_BUTTON_R;
config.wpad_keymap[4*3][KEY_BUTTONZ] = WIIDRC_BUTTON_X;
config.wpad_keymap[4*3][KEY_MODE] = WIIDRC_BUTTON_MINUS;
config.wpad_keymap[4*3][KEY_MENU] = WIIDRC_BUTTON_HOME;
}
#endif
/* Default player inputs */
for (i=0; i<MAX_INPUTS; i++)
{
config.input[i].device = -1;
config.input[i].port = i%4;
config.input[i].padtype = DEVICE_PAD2B | DEVICE_PAD3B | DEVICE_PAD6B; /* autodetected */
}
#ifdef HW_RVL
/* autodetect connected WiiU Gamepad Controller */
if (WiiDRC_Inited() && WiiDRC_Connected())
{
config.input[0].device = 4;
config.input[0].port = 0;
i = 1;
}
else
{
i = 0;
}
/* autodetect connected Wii Controllers */
do
{
exp = 255;
WPAD_Probe(i, &exp);
if (exp == WPAD_EXP_CLASSIC)
{
/* use Classic Controller */
config.input[i].device = 3;
config.input[i].port = i;
}
else if (exp == WPAD_EXP_NUNCHUK)
{
/* use Wiimote + Nunchuk */
config.input[i].device = 2;
config.input[i].port = i;
}
else if (exp != 255)
{
/* use Wiimote by default */
config.input[i].device = 1;
config.input[i].port = i;
}
else
{
/* look for unused Wiimotes */
for (j=0; j<i; j++)
{
/* Wiimote could still be used when Classic Controller has been assigned */
if (config.input[j].device == 3)
{
/* make sure this is not a Wii U Pro Controller */
WPADData *data = WPAD_Data(config.input[j].port);
if (data->exp.classic.type != 2)
{
/* Wiimote is available */
config.input[i].device = 1;
config.input[i].port = j;
break;
}
}
}
}
i++;
}
while (i < 4);
#endif
/* Autodetect Gamecube Controllers */
VIDEO_WaitVSync();
exp = PAD_ScanPads();
for (i=0; i<4; i++)
{
/* check if Gamecube Controller is connected */
if (exp & (1 << i))
{
for (j=0; j<MAX_INPUTS; j++)
{
/* look for the first unassigned player */
if (config.input[j].device == -1)
{
config.input[j].device = 0;
config.input[j].port = i;
j = MAX_INPUTS;
}
}
}
}
}
void gx_input_Config(u8 chan, u8 device, u8 type)
{
int first_key, last_key;
/* emulated device */
switch (type)
{
case DEVICE_PADDLE:
case DEVICE_PAD2B:
case DEVICE_SPORTSPAD:
{
first_key = KEY_BUTTONB;
last_key = KEY_START;
sprintf(keyname[KEY_BUTTONB],"Button 1");
sprintf(keyname[KEY_BUTTONC],"Button 2");
sprintf(keyname[KEY_START],"PAUSE Button");
break;
}
case DEVICE_XE_1AP:
{
first_key = KEY_BUTTONA;
last_key = KEY_MODE;
sprintf(keyname[KEY_BUTTONA],"Button A");
sprintf(keyname[KEY_BUTTONB],"Button B");
sprintf(keyname[KEY_BUTTONC],"Button C");
sprintf(keyname[KEY_START],"START Button");
sprintf(keyname[KEY_BUTTONX],"Button D");
sprintf(keyname[KEY_BUTTONY],"Button E1");
sprintf(keyname[KEY_BUTTONZ],"Button E2");
sprintf(keyname[KEY_MODE],"SELECT Button");
break;
}
case DEVICE_MOUSE:
{
first_key = KEY_BUTTONA;
last_key = KEY_START;
sprintf(keyname[KEY_BUTTONA],"Middle Button");
sprintf(keyname[KEY_BUTTONB],"Left Button");
sprintf(keyname[KEY_BUTTONC],"Right Button");
sprintf(keyname[KEY_START],"START Button");
break;
}
case DEVICE_PAD3B:
{
first_key = KEY_BUTTONA;
last_key = KEY_START;
sprintf(keyname[KEY_BUTTONA],"Button A");
sprintf(keyname[KEY_BUTTONB],"Button B");
sprintf(keyname[KEY_BUTTONC],"Button C");
sprintf(keyname[KEY_START],"START Button");
break;
}
case DEVICE_PAD6B:
{
first_key = KEY_BUTTONA;
last_key = KEY_MODE;
sprintf(keyname[KEY_BUTTONA],"Button A");
sprintf(keyname[KEY_BUTTONB],"Button B");
sprintf(keyname[KEY_BUTTONC],"Button C");
sprintf(keyname[KEY_START],"START Button");
sprintf(keyname[KEY_BUTTONX],"Button X");
sprintf(keyname[KEY_BUTTONY],"Button Y");
sprintf(keyname[KEY_BUTTONZ],"Button Z");
sprintf(keyname[KEY_MODE],"MODE Button");
break;
}
case DEVICE_LIGHTGUN:
{
first_key = KEY_BUTTONA;
last_key = KEY_START;
if (input.system[1] == SYSTEM_MENACER)
{
sprintf(keyname[KEY_BUTTONA],"TRIGGER Button");
sprintf(keyname[KEY_BUTTONB],"Button B");
sprintf(keyname[KEY_BUTTONC],"Button C");
sprintf(keyname[KEY_START],"START Button");
}
else if (input.system[1] == SYSTEM_JUSTIFIER)
{
sprintf(keyname[KEY_BUTTONA],"TRIGGER Button");
sprintf(keyname[KEY_BUTTONB],"N.A");
sprintf(keyname[KEY_BUTTONC],"N.A");
sprintf(keyname[KEY_START],"START Button");
}
else
{
sprintf(keyname[KEY_BUTTONA],"TRIGGER Button");
sprintf(keyname[KEY_BUTTONB],"N.A");
sprintf(keyname[KEY_BUTTONC],"N.A");
sprintf(keyname[KEY_START],"PAUSE Button");
}
break;
}
case DEVICE_PICO:
{
first_key = KEY_BUTTONA;
last_key = KEY_BUTTONB;
sprintf(keyname[KEY_BUTTONA],"PEN Button");
sprintf(keyname[KEY_BUTTONB],"RED Button");
break;
}
case DEVICE_TEREBI:
{
first_key = KEY_BUTTONA;
last_key = KEY_BUTTONA;
sprintf(keyname[KEY_BUTTONA],"PEN Button");
break;
}
case DEVICE_GRAPHIC_BOARD:
{
first_key = KEY_BUTTONA;
last_key = KEY_START;
sprintf(keyname[KEY_BUTTONA],"PEN Button");
sprintf(keyname[KEY_BUTTONB],"DO Button");
sprintf(keyname[KEY_BUTTONC],"MENU Button");
sprintf(keyname[KEY_START],"PAUSE Button");
break;
}
default:
{
first_key = KEY_BUTTONA;
last_key = KEY_BUTTONA;
sprintf(keyname[KEY_BUTTONA],"N.A");
GUI_WaitPrompt("Info","Activator is not configurable !");
break;
}
}
/* Input device */
switch (device)
{
case 0:
{
pad_config(chan, first_key, last_key);
break;
}
default:
{
#ifdef HW_RVL
wpad_config(device - 1, chan, first_key, last_key);
#endif
break;
}
}
}
void gx_input_UpdateEmu(void)
{
/* Update GC controllers status */
PAD_ScanPads();
#ifdef HW_RVL
/* Update Wii controllers status */
WPAD_ScanPads();
/* Default Wii controller menu keys */
if (WPAD_ButtonsDown(0) & (WPAD_BUTTON_HOME | WPAD_CLASSIC_BUTTON_HOME))
{
/* Default fast-forward key combo */
if (WPAD_ButtonsHeld(0) & (WPAD_BUTTON_MINUS | WPAD_CLASSIC_BUTTON_MINUS))
{
audioSync ^= AUDIO_WAIT;
videoSync = (audioSync && config.vsync && (gc_pal != vdp_pal)) ? VIDEO_WAIT : 0;
return;
}
/* Return to main menu */
ConfigRequested = 1;
return;
}
#endif
int i, player = 0;
for (i=0; i<MAX_DEVICES; i++)
{
/* update inputs */
if (input.dev[i] != NO_DEVICE)
{
/* clear key status */
input.pad[i] = 0;
if (config.input[player].device == 0)
{
pad_update(config.input[player].port, i);
}
#ifdef HW_RVL
else if (config.input[player].device > 0)
{
wpad_update(config.input[player].port, i, config.input[player].device - 1);
}
#endif
/* increment player index */
player ++;
}
}
/* Update RAM patches */
RAMCheatUpdate();
}
/* Menu inputs update function */
void gx_input_UpdateMenu(void)
{
/* Check if inputs update are disabled */
if (inputs_disabled) return;
int i;
s8 x, y;
u16 pp, hp;
#ifdef HW_RVL
u32 pw, hw, pwu, hwu;
#endif
/* PAD status update */
PAD_ScanPads();
/* Check all PAD ports */
for (i=0; i<4; i++)
{
/* PAD pressed keys */
pp = PAD_ButtonsDown(i);
/* PAD held keys (direction/selection only) */
hp = PAD_ButtonsHeld(i) & PAD_BUTTONS_HELD;
/* PAD analog sticks (handled as held direction keys) */
x = PAD_StickX(i);
y = PAD_StickY(i);
if (x > ANALOG_SENSITIVITY) hp |= PAD_BUTTON_RIGHT;
else if (x < -ANALOG_SENSITIVITY) hp |= PAD_BUTTON_LEFT;
else if (y > ANALOG_SENSITIVITY) hp |= PAD_BUTTON_UP;
else if (y < -ANALOG_SENSITIVITY) hp |= PAD_BUTTON_DOWN;
/* Ignore other ports once first used PAD controlled is found */
if (pp || hp) break;
}
#ifdef HW_RVL
/* WPAD status update */
WPAD_ScanPads();
/* Check all WPAD ports */
for (i=0; i<4; i++)
{
/* WPAD data */
WPADData *data = WPAD_Data(i);
/* WPAD pressed keys */
pw = data->btns_d;
/* WPAD held keys (direction/selection only) */
hw = data->btns_h & WPAD_BUTTONS_HELD;
/* WPAD analog sticks (handled as held direction keys) */
x = wpad_StickX(data, 0);
y = wpad_StickY(data, 0);
if (x > ANALOG_SENSITIVITY) hp |= PAD_BUTTON_RIGHT;
else if (x < -ANALOG_SENSITIVITY) hp |= PAD_BUTTON_LEFT;
else if (y > ANALOG_SENSITIVITY) hp |= PAD_BUTTON_UP;
else if (y < -ANALOG_SENSITIVITY) hp |= PAD_BUTTON_DOWN;
/* Wiimote orientation */
WPAD_IR(i, &m_input.ir);
/* Ignore other ports once first used WPAD controller is found */
if (m_input.ir.valid || pw || hw) break;
}
/* Check WiiU GamePad status */
if (WiiDRC_Inited())
{
WiiDRC_ScanPads();
if (WiiDRC_ShutdownRequested())
{
Shutdown = ConfigRequested = 1;
reload = 0;
return;
}
pwu = WiiDRC_ButtonsDown();
hwu = WiiDRC_ButtonsHeld() & WIIU_BUTTONS_HELD;
x = WiiDRC_lStickX();
y = WiiDRC_lStickY();
if (x > ANALOG_SENSITIVITY) hp |= PAD_BUTTON_RIGHT;
else if (x < -ANALOG_SENSITIVITY) hp |= PAD_BUTTON_LEFT;
else if (y > ANALOG_SENSITIVITY) hp |= PAD_BUTTON_UP;
else if (y < -ANALOG_SENSITIVITY) hp |= PAD_BUTTON_DOWN;
}
else
{
pwu = 0;
hwu = 0;
}
#endif
/* check if any direction/selection key is being held or just being pressed/released */
#ifdef HW_RVL
if (pp||pw||pwu) held_cnt = 0;
else if (hp||hw||hwu) held_cnt++;
else held_cnt = 0;
#else
if (pp) held_cnt = 0;
else if (hp) held_cnt++;
else held_cnt = 0;
#endif
/* initial delay (prevents triggering to start immediately) */
if (held_cnt > HELD_DELAY)
{
/* key triggering */
pp |= hp;
#ifdef HW_RVL
pw |= hw;
pwu |= hwu;
#endif
/* delay until next triggering (adjusts direction/selection update speed) */
held_cnt -= HELD_SPEED;
}
#ifdef HW_RVL
/* Wiimote & Classic Controller direction keys */
if (m_input.ir.valid)
{
/* Wiimote is handled vertically */
if (pw & (WPAD_BUTTON_UP|WPAD_CLASSIC_BUTTON_UP)) pp |= PAD_BUTTON_UP;
else if (pw & (WPAD_BUTTON_DOWN|WPAD_CLASSIC_BUTTON_DOWN)) pp |= PAD_BUTTON_DOWN;
else if (pw & (WPAD_BUTTON_LEFT|WPAD_CLASSIC_BUTTON_LEFT)) pp |= PAD_BUTTON_LEFT;
else if (pw & (WPAD_BUTTON_RIGHT|WPAD_CLASSIC_BUTTON_RIGHT)) pp |= PAD_BUTTON_RIGHT;
/* Wiimote pointer user calibration */
m_input.ir.x += config.calx;
m_input.ir.y += config.caly;
}
else
{
/* Wiimote is handled horizontally */
if (pw & (WPAD_BUTTON_UP|WPAD_CLASSIC_BUTTON_LEFT)) pp |= PAD_BUTTON_LEFT;
else if (pw & (WPAD_BUTTON_DOWN|WPAD_CLASSIC_BUTTON_RIGHT)) pp |= PAD_BUTTON_RIGHT;
else if (pw & (WPAD_BUTTON_LEFT|WPAD_CLASSIC_BUTTON_DOWN)) pp |= PAD_BUTTON_DOWN;
else if (pw & (WPAD_BUTTON_RIGHT|WPAD_CLASSIC_BUTTON_UP)) pp |= PAD_BUTTON_UP;
}
/* WPAD button keys */
if (pw & (WPAD_BUTTON_2|WPAD_BUTTON_A|WPAD_CLASSIC_BUTTON_A)) pp |= PAD_BUTTON_A;
if (pw & (WPAD_BUTTON_1|WPAD_BUTTON_B|WPAD_CLASSIC_BUTTON_B)) pp |= PAD_BUTTON_B;
if (pw & (WPAD_BUTTON_HOME|WPAD_CLASSIC_BUTTON_HOME)) pp |= PAD_TRIGGER_Z;
if (pw & (WPAD_BUTTON_PLUS|WPAD_CLASSIC_BUTTON_PLUS|WPAD_CLASSIC_BUTTON_FULL_L)) pp |= PAD_TRIGGER_L;
if (pw & (WPAD_BUTTON_MINUS|WPAD_CLASSIC_BUTTON_MINUS|WPAD_CLASSIC_BUTTON_FULL_R)) pp |= PAD_TRIGGER_R;
/* WiiU GamePad direction keys */
if (pwu & WIIDRC_BUTTON_UP) pp |= PAD_BUTTON_UP;
else if (pwu & WIIDRC_BUTTON_DOWN) pp |= PAD_BUTTON_DOWN;
else if (pwu & WIIDRC_BUTTON_LEFT) pp |= PAD_BUTTON_LEFT;
else if (pwu & WIIDRC_BUTTON_RIGHT) pp |= PAD_BUTTON_RIGHT;
/* WiiU GamePad button keys */
if (pwu & WIIDRC_BUTTON_A) pp |= PAD_BUTTON_A;
if (pwu & WIIDRC_BUTTON_B) pp |= PAD_BUTTON_B;
if (pwu & WIIDRC_BUTTON_HOME) pp |= PAD_TRIGGER_Z;
if (pwu & (WIIDRC_BUTTON_PLUS|WIIDRC_BUTTON_L|WIIDRC_BUTTON_ZL)) pp |= PAD_TRIGGER_L;
if (pwu & (WIIDRC_BUTTON_MINUS|WIIDRC_BUTTON_R|WIIDRC_BUTTON_ZR)) pp |= PAD_TRIGGER_R;
#endif
/* Update menu inputs */
m_input.keys = pp;
}
Reference in New Issue View Git Blame Copy Permalink