static void force_controller_keyboard(int n64CtrlIdx)
{
if (n64CtrlIdx < 0 || n64CtrlIdx > 3)
{
DebugMessage(M64MSG_ERROR, "internal assert in ForceControllerKeyboard. n64CtrlIdx=%i", n64CtrlIdx);
return;
}
DebugMessage(M64MSG_INFO, "N64 Controller #%i: Forcing default keyboard configuration", n64CtrlIdx+1);
auto_set_defaults(DEVICE_NOT_JOYSTICK, "Keyboard");
if (load_controller_config("AutoConfig0", n64CtrlIdx, 1) > 0)
{
/* use ConfigSetDefault*() to save this auto-config if config section was empty */
save_controller_config(n64CtrlIdx, "AutoKeyboard");
}
else
{
DebugMessage(M64MSG_ERROR, "Autoconfig keyboard setup invalid");
}
ConfigDeleteSection("AutoConfig0");
}
void load_configuration(int bPrintSummary)
{
char SectionName[32];
const char *JoyName;
int joy_found = 0, joy_plugged = 0;
int readOK;
int n64CtrlIdx, sdlCtrlIdx, j;
/* loop through all 4 simulated N64 controllers */
for (n64CtrlIdx=0,sdlCtrlIdx=0; n64CtrlIdx < 4; n64CtrlIdx++)
{
/* reset the controller configuration */
clear_controller(n64CtrlIdx);
/* try to load the config from the core's configuration api */
sprintf(SectionName, "Input-SDL-Control%i", n64CtrlIdx + 1);
readOK = load_controller_config(SectionName, n64CtrlIdx, 0);
if (readOK <= 0 || controller[n64CtrlIdx].device == DEVICE_AUTO)
{
int ControllersFound = 0;
/* make sure that SDL device number hasn't already been used for a different N64 controller */
for (j = 0; j < n64CtrlIdx; j++)
{
if (controller[j].device == sdlCtrlIdx)
{
sdlCtrlIdx++;
j = -1;
}
}
/* if auto / bad config, get joystick name based on SDL order */
JoyName = get_sdl_joystick_name(sdlCtrlIdx);
/* reset the controller configuration again and try to auto-configure */
ControllersFound = auto_set_defaults(sdlCtrlIdx, JoyName);
sdlCtrlIdx++;
if (ControllersFound == 0)
{
controller[n64CtrlIdx].device = DEVICE_AUTO;
controller[n64CtrlIdx].control->Present = 0;
DebugMessage(M64MSG_WARNING, "N64 Controller #%i: Disabled, SDL joystick %i is not available", n64CtrlIdx+1, sdlCtrlIdx-1);
}
else
{
for (j = 0; j < ControllersFound; j++) /* a USB device may have > 1 controller */
{
sprintf(SectionName, "AutoConfig%i", j);
if (n64CtrlIdx + j > 3)
{
ConfigDeleteSection(SectionName);
continue;
}
clear_controller(n64CtrlIdx + j);
if (load_controller_config(SectionName, n64CtrlIdx + j, 1) > 0)
{
/* use ConfigSetDefault*() to save this auto-config if config section was empty */
save_controller_config(n64CtrlIdx + j, JoyName);
DebugMessage(M64MSG_INFO, "N64 Controller #%i: Using auto-config for SDL joystick %i ('%s')", n64CtrlIdx+1, controller[n64CtrlIdx].device, JoyName);
}
else
{
DebugMessage(M64MSG_ERROR, "Autoconfig data invalid for controller #%i in device '%s'", j + 1, JoyName);
}
ConfigDeleteSection(SectionName);
}
n64CtrlIdx += ControllersFound - 1;
continue;
}
}
else if (controller[n64CtrlIdx].device >= 0)
{
/* if joystick found in cfg, take its SDL number from there */
JoyName = get_sdl_joystick_name(controller[n64CtrlIdx].device);
/* valid joystick configuration was read; check if the specified joystick is available in SDL */
if (JoyName == NULL)
{
controller[n64CtrlIdx].device = DEVICE_AUTO;
controller[n64CtrlIdx].control->Present = 0;
DebugMessage(M64MSG_WARNING, "N64 Controller #%i: Disabled, SDL joystick %i is not available", n64CtrlIdx+1, controller[n64CtrlIdx].device);
}
else
DebugMessage(M64MSG_INFO, "N64 Controller #%i: Using stored config for SDL joystick %i ('%s')", n64CtrlIdx+1, controller[n64CtrlIdx].device, JoyName);
}
else /* controller is configured for keyboard/mouse */
{
DebugMessage(M64MSG_INFO, "N64 Controller #%i: Using keyboard/mouse", n64CtrlIdx+1);
}
}
/* see how many joysticks were found */
joy_found = 0, joy_plugged = 0;
for (j = 0; j < 4; j++)
{
if (controller[j].device >= 0 || controller[j].device == DEVICE_NOT_JOYSTICK)
{
joy_found++;
if (controller[j].control->Present)
joy_plugged++;
}
}
/* fallback to keyboard if no joysticks are available and 'plugged in' */
if (joy_found == 0 || joy_plugged == 0)
{
force_controller_keyboard(0);
}
if (bPrintSummary)
{
if (joy_found > 0 && joy_plugged > 0)
{
DebugMessage(M64MSG_INFO, "%i controller(s) found, %i plugged in and usable in the emulator", joy_found, joy_plugged);
}
else
{
if (joy_found == 0)
DebugMessage(M64MSG_WARNING, "No joysticks/controllers found");
else if (joy_plugged == 0)
DebugMessage(M64MSG_WARNING, "%i controllers found, but none were 'plugged in'", joy_found);
}
}
}
void load_configuration(int bPreConfig)
{
char SectionName[32];
int joy_plugged = 0;
int n64CtrlIdx, sdlCtrlIdx, j;
int sdlNumDevUsed = 0;
int sdlDevicesUsed[4];
eModeType OrigControlMode[4], ControlMode[4];
int ControlDevice[4];
char DeviceName[4][256];
int ActiveControllers = 0;
int sdlNumJoysticks = get_sdl_num_joysticks();
float fVersion = 0.0f;
const char *sdl_name;
int ControllersFound = 0;
/* tell user how many SDL joysticks are available */
if (!bPreConfig)
DebugMessage(M64MSG_INFO, "%i SDL joysticks were found.", sdlNumJoysticks);
/* loop through 4 N64 controllers, initializing and validating special section parameters */
for (n64CtrlIdx=0; n64CtrlIdx < 4; n64CtrlIdx++)
{
m64p_handle pConfig;
/* reset the controller configuration */
clear_controller(n64CtrlIdx);
/* Open the configuration section for this controller */
sprintf(SectionName, "Input-SDL-Control%i", n64CtrlIdx + 1);
if (ConfigOpenSection(SectionName, &pConfig) != M64ERR_SUCCESS)
{
// this should never happen
DebugMessage(M64MSG_ERROR, "Couldn't open config section '%s'. Aborting...", SectionName);
return;
}
/* Check version number, and if it doesn't match: delete the config section */
fVersion = 0.0f;
if (ConfigGetParameter(pConfig, "version", M64TYPE_FLOAT, &fVersion, sizeof(float)) != M64ERR_SUCCESS || ((int) fVersion) != ((int) CONFIG_VERSION))
{
DebugMessage(M64MSG_WARNING, "Missing or incompatible config section '%s'. Clearing.", SectionName);
ConfigDeleteSection(SectionName);
// set local controller default parameters
OrigControlMode[n64CtrlIdx] = ControlMode[n64CtrlIdx] = E_MODE_FULL_AUTO;
ControlDevice[n64CtrlIdx] = DEVICE_NO_JOYSTICK;
DeviceName[n64CtrlIdx][0] = 0;
// write blank config for GUI front-ends
init_controller_config(n64CtrlIdx, "", E_MODE_FULL_AUTO);
// save it to the file too
ConfigSaveSection(SectionName);
}
else
{
if (ConfigGetParameter(pConfig, "mode", M64TYPE_INT, &OrigControlMode[n64CtrlIdx], sizeof(int)) != M64ERR_SUCCESS ||
(int) OrigControlMode[n64CtrlIdx] < 0 || (int) OrigControlMode[n64CtrlIdx] > 2)
{
if (!bPreConfig)
DebugMessage(M64MSG_WARNING, "Missing or invalid 'mode' parameter in config section '%s'. Setting to 2 (Fully Auto)", SectionName);
OrigControlMode[n64CtrlIdx] = E_MODE_FULL_AUTO;
}
ControlMode[n64CtrlIdx] = OrigControlMode[n64CtrlIdx];
if (ConfigGetParameter(pConfig, "device", M64TYPE_INT, &ControlDevice[n64CtrlIdx], sizeof(int)) != M64ERR_SUCCESS)
{
if (!bPreConfig)
DebugMessage(M64MSG_WARNING, "Missing 'device' parameter in config section '%s'. Setting to -1 (No joystick)", SectionName);
ControlDevice[n64CtrlIdx] = DEVICE_NO_JOYSTICK;
}
if (ConfigGetParameter(pConfig, "name", M64TYPE_STRING, DeviceName[n64CtrlIdx], 256) != M64ERR_SUCCESS)
{
DeviceName[n64CtrlIdx][0] = 0;
}
}
}
/* loop through 4 N64 controllers and set up those in Fully Manual mode */
for (n64CtrlIdx=0; n64CtrlIdx < 4; n64CtrlIdx++)
{
if (ControlMode[n64CtrlIdx] != E_MODE_MANUAL)
continue;
/* load the stored configuration (disregard any errors) */
sprintf(SectionName, "Input-SDL-Control%i", n64CtrlIdx + 1);
load_controller_config(SectionName, n64CtrlIdx, ControlDevice[n64CtrlIdx]);
/* if this config uses an SDL joystick, mark it as used */
if (ControlDevice[n64CtrlIdx] == DEVICE_NO_JOYSTICK)
{
if (!bPreConfig)
DebugMessage(M64MSG_INFO, "N64 Controller #%i: Using manual config with no SDL joystick (keyboard/mouse only)", n64CtrlIdx+1);
}
else
{
sdlDevicesUsed[sdlNumDevUsed++] = ControlDevice[n64CtrlIdx];
if (!bPreConfig)
DebugMessage(M64MSG_INFO, "N64 Controller #%i: Using manual config for SDL joystick %i", n64CtrlIdx+1, ControlDevice[n64CtrlIdx]);
}
ActiveControllers++;
}
/* now loop through again, setting up those in Named Auto mode */
for (n64CtrlIdx=0; n64CtrlIdx < 4; n64CtrlIdx++)
{
if (ControlMode[n64CtrlIdx] != E_MODE_NAMED_AUTO)
continue;
/* if name is empty, then use full auto mode instead */
if (DeviceName[n64CtrlIdx][0] == 0)
{
ControlMode[n64CtrlIdx] = E_MODE_FULL_AUTO;
continue;
}
sprintf(SectionName, "Input-SDL-Control%i", n64CtrlIdx + 1);
/* if user is looking for a keyboard, set that up */
if (strcasecmp(DeviceName[n64CtrlIdx], "Keyboard") == 0)
{
auto_set_defaults(DEVICE_NO_JOYSTICK, "Keyboard");
if (load_controller_config("AutoConfig0", n64CtrlIdx, DEVICE_NO_JOYSTICK) > 0)
{
if (!bPreConfig)
DebugMessage(M64MSG_INFO, "N64 Controller #%i: Using auto-config for keyboard", n64CtrlIdx+1);
/* copy the auto-config settings to the controller config section */
auto_copy_inputconfig("AutoConfig0", SectionName, "Keyboard");
ActiveControllers++;
ConfigSaveSection(SectionName);
}
else
{
DebugMessage(M64MSG_ERROR, "Autoconfig keyboard setup invalid");
}
ConfigDeleteSection("AutoConfig0");
continue;
}
/* search for an unused SDL device with the matching name */
for (sdlCtrlIdx=0; sdlCtrlIdx < sdlNumJoysticks; sdlCtrlIdx++)
{
/* check if this one is in use */
int deviceAlreadyUsed = 0;
for (j = 0; j < sdlNumDevUsed; j++)
{
if (sdlDevicesUsed[j] == sdlCtrlIdx)
deviceAlreadyUsed = 1;
}
if (deviceAlreadyUsed)
continue;
/* check if the name matches */
sdl_name = get_sdl_joystick_name(sdlCtrlIdx);
if (sdl_name != NULL && strncmp(DeviceName[n64CtrlIdx], sdl_name, 255) == 0)
{
/* set up one or more controllers for this SDL device, if present in InputAutoConfig.ini */
int ControllersFound = setup_auto_controllers(bPreConfig, n64CtrlIdx, sdlCtrlIdx, sdl_name, ControlMode, OrigControlMode, DeviceName);
if (ControllersFound == 0)
{
// error: no auto-config found for this SDL device
DebugMessage(M64MSG_ERROR, "No auto-config found for joystick named '%s' in InputAutoConfig.ini", sdl_name);
// mark this device as being used just so we don't complain about it again
sdlDevicesUsed[sdlNumDevUsed++] = sdlCtrlIdx;
// quit looking for SDL joysticks which match the name, because there's no valid autoconfig for that name.
// this controller will be unused; skip to the next one
break;
}
/* mark this sdl device as used */
sdlDevicesUsed[sdlNumDevUsed++] = sdlCtrlIdx;
ActiveControllers += ControllersFound;
break;
}
}
/* if we didn't find a match for this joystick name, then set the controller to fully auto */
if (sdlCtrlIdx == sdlNumJoysticks)
{
if (!bPreConfig)
DebugMessage(M64MSG_WARNING, "N64 Controller #%i: No SDL joystick found matching name '%s'. Using full auto mode.", n64CtrlIdx+1, DeviceName[n64CtrlIdx]);
ControlMode[n64CtrlIdx] = E_MODE_FULL_AUTO;
}
}
/* Final loop through N64 controllers, setting up those in Full Auto mode */
for (n64CtrlIdx=0; n64CtrlIdx < 4; n64CtrlIdx++)
{
if (ControlMode[n64CtrlIdx] != E_MODE_FULL_AUTO)
continue;
sprintf(SectionName, "Input-SDL-Control%i", n64CtrlIdx + 1);
/* search for an unused SDL device */
for (sdlCtrlIdx=0; sdlCtrlIdx < sdlNumJoysticks; sdlCtrlIdx++)
{
/* check if this one is in use */
int deviceAlreadyUsed = 0;
for (j = 0; j < sdlNumDevUsed; j++)
{
if (sdlDevicesUsed[j] == sdlCtrlIdx)
deviceAlreadyUsed = 1;
}
if (deviceAlreadyUsed)
continue;
/* set up one or more controllers for this SDL device, if present in InputAutoConfig.ini */
sdl_name = get_sdl_joystick_name(sdlCtrlIdx);
ControllersFound = setup_auto_controllers(bPreConfig, n64CtrlIdx, sdlCtrlIdx, sdl_name, ControlMode, OrigControlMode, DeviceName);
if (!bPreConfig && ControllersFound == 0)
{
// error: no auto-config found for this SDL device
DebugMessage(M64MSG_ERROR, "No auto-config found for joystick named '%s' in InputAutoConfig.ini", sdl_name);
// mark this device as being used just so we don't complain about it again
sdlDevicesUsed[sdlNumDevUsed++] = sdlCtrlIdx;
// keep trying more SDL devices to see if we can auto-config one for this N64 controller
continue;
}
/* mark this sdl device as used */
sdlDevicesUsed[sdlNumDevUsed++] = sdlCtrlIdx;
ActiveControllers += ControllersFound;
break;
}
/* if this N64 controller was not activated, set device to -1 */
if (sdlCtrlIdx == sdlNumJoysticks)
{
m64p_handle section;
if (ConfigOpenSection(SectionName, §ion) == M64ERR_SUCCESS)
{
const int iNoDevice = -1;
ConfigSetParameter(section, "device", M64TYPE_INT, &iNoDevice);
if (OrigControlMode[n64CtrlIdx] == E_MODE_FULL_AUTO)
ConfigSetParameter(section, "name", M64TYPE_STRING, "");
ConfigSaveSection(SectionName);
}
}
}
/* fallback to keyboard if no controllers were configured */
if (ActiveControllers == 0)
{
if (!bPreConfig)
DebugMessage(M64MSG_INFO, "N64 Controller #1: Forcing default keyboard configuration");
auto_set_defaults(DEVICE_NO_JOYSTICK, "Keyboard");
if (load_controller_config("AutoConfig0", 0, DEVICE_NO_JOYSTICK) > 0)
{
/* copy the auto-config settings to the controller config section */
if (OrigControlMode[0] == E_MODE_FULL_AUTO)
auto_copy_inputconfig("AutoConfig0", "Input-SDL-Control1", "Keyboard");
else
auto_copy_inputconfig("AutoConfig0", "Input-SDL-Control1", NULL); // don't overwrite 'name' parameter
ActiveControllers++;
ConfigSaveSection("Input-SDL-Control1");
}
else
{
DebugMessage(M64MSG_ERROR, "Autoconfig keyboard setup invalid");
}
ConfigDeleteSection("AutoConfig0");
}
/* see how many joysticks are plugged in */
joy_plugged = 0;
for (j = 0; j < 4; j++)
{
if (controller[j].control->Present)
joy_plugged++;
}
/* print out summary info message */
if (!bPreConfig)
{
if (joy_plugged > 0)
{
DebugMessage(M64MSG_INFO, "%i controller(s) found, %i plugged in and usable in the emulator", ActiveControllers, joy_plugged);
}
else
{
if (ActiveControllers == 0)
DebugMessage(M64MSG_WARNING, "No joysticks/controllers found");
else
DebugMessage(M64MSG_WARNING, "%i controllers found, but none were 'plugged in'", ActiveControllers);
}
}
}
/****** Initializes SDL, OpenGL and Video and Window ******/
bool init()
{
/* Initialize All SDL Systems */
if(SDL_Init(SDL_INIT_EVERYTHING) < 0)
{
std::cout<<"SDL could not be initialized!\n";
return false;
}
/* Use OpenGL for Rendering */
if(gfx::hw_accel)
{
/* Initialize SDL Video - OpenGL */
if(SDL_SetVideoMode(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP, SDL_RESIZABLE | SDL_OPENGL) == NULL)
{
std::cout<<"SDL Video could not be initialized!\n";
return false;
}
/* Initialize OpenGL */
if(opengl_init() == false)
{
std::cout<<"OpenGL could not be initialized!\n";
return false;
}
std::cout<<"Renderer - OpenGL \n";
}
/* Use SDL for Rendering */
else
{
/* Initialize SDL Video - SDL */
gfx::main_screen = SDL_SetVideoMode(SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP, SDL_SWSURFACE);
if(gfx::main_screen == NULL)
{
std::cout<<"SDL Video could not be initialized!\n";
return false;
}
std::cout<<"Renderer - SDL \n";
}
/* Initialize TTF */
if(TTF_Init() == -1)
{
std::cout<<"SDL TTF could not be initialized\n";
return false;
}
/* Load controller configuration */
if(!load_controller_config("Config/controls.xgl")) { return false; }
SDL_WM_SetCaption("RPG Game - Development", NULL);
/* Print other info */
std::cout<<"RPG Game copyright Daniel & Alex Baxter 2012\n";
std::cout<<"Version 0.1 " << __DATE__ << " " << __TIME__ << "\n";
return true;
}
static int setup_auto_controllers(int bPreConfig, int n64CtrlStart, int sdlCtrlIdx, const char *sdlJoyName, eModeType ControlMode[], eModeType OrigControlMode[], char DeviceName[][256])
{
char SectionName[32];
int ActiveControllers = 0;
int j;
/* create auto-config section(s) for this joystick (if this joystick is in the InputAutoConfig.ini) */
int ControllersFound = auto_set_defaults(sdlCtrlIdx, sdlJoyName);
if (ControllersFound == 0)
return 0;
/* copy the auto-config settings to the controller config section, and load our plugin joystick config from this */
sprintf(SectionName, "Input-SDL-Control%i", n64CtrlStart + 1);
if (OrigControlMode[n64CtrlStart] == E_MODE_FULL_AUTO)
auto_copy_inputconfig("AutoConfig0", SectionName, sdlJoyName);
else
auto_copy_inputconfig("AutoConfig0", SectionName, NULL); // don't overwrite 'name' parameter if original mode was "named auto"
if (load_controller_config("AutoConfig0", n64CtrlStart, sdlCtrlIdx) > 0)
{
if (!bPreConfig)
DebugMessage(M64MSG_INFO, "N64 Controller #%i: Using auto-config with SDL joystick %i ('%s')", n64CtrlStart+1, sdlCtrlIdx, sdlJoyName);
ActiveControllers++;
ConfigSaveSection(SectionName);
}
else
{
if (!bPreConfig)
DebugMessage(M64MSG_ERROR, "Autoconfig data invalid for SDL joystick '%s'", sdlJoyName);
}
ConfigDeleteSection("AutoConfig0");
/* we have to handle the unfortunate case of a USB device mapping more than > 1 controller */
if (ControllersFound > 1)
{
for (j = 1; j < ControllersFound; j++)
{
char AutoSectionName[32];
sprintf(AutoSectionName, "AutoConfig%i", j);
/* if this would be > 4th controller, then just delete the auto-config */
if (n64CtrlStart + j >= 4)
{
ConfigDeleteSection(AutoSectionName);
continue;
}
/* look for another N64 controller that is in AUTO mode */
if (ControlMode[n64CtrlStart+j] == E_MODE_FULL_AUTO ||
(ControlMode[n64CtrlStart+j] == E_MODE_NAMED_AUTO && strncmp(DeviceName[n64CtrlStart+j], sdlJoyName, 255) == 0))
{
sprintf(SectionName, "Input-SDL-Control%i", n64CtrlStart + j + 1);
/* load our plugin joystick settings from the autoconfig */
if (load_controller_config(AutoSectionName, n64CtrlStart+j, sdlCtrlIdx) > 0)
{
/* copy the auto-config settings to the controller config section */
if (OrigControlMode[n64CtrlStart+j] == E_MODE_FULL_AUTO)
auto_copy_inputconfig(AutoSectionName, SectionName, sdlJoyName);
else
auto_copy_inputconfig(AutoSectionName, SectionName, NULL); // don't overwrite 'name' parameter if original mode was "named auto"
if (!bPreConfig)
DebugMessage(M64MSG_INFO, "N64 Controller #%i: Using auto-config with SDL joystick %i ('%s')", n64CtrlStart+j+1, sdlCtrlIdx, sdlJoyName);
ActiveControllers++;
ConfigSaveSection(SectionName);
/* set the local controller mode to Manual so that we won't re-configure this controller in the next loop */
ControlMode[n64CtrlStart+j] = E_MODE_MANUAL;
}
else
{
if (!bPreConfig)
DebugMessage(M64MSG_ERROR, "Autoconfig data invalid for SDL device '%s'", sdlJoyName);
}
/* delete the autoconfig section */
ConfigDeleteSection(AutoSectionName);
}
}
}
return ActiveControllers;
}