int main_set_core_defaults(void)
{
float fConfigParamsVersion;
int bSaveConfig = 0, bUpgrade = 0;
if (ConfigGetParameter(g_CoreConfig, "Version", M64TYPE_FLOAT, &fConfigParamsVersion, sizeof(float)) != M64ERR_SUCCESS)
{
DebugMessage(M64MSG_WARNING, "No version number in 'Core' config section. Setting defaults.");
ConfigDeleteSection("Core");
ConfigOpenSection("Core", &g_CoreConfig);
bSaveConfig = 1;
}
else if (((int) fConfigParamsVersion) != ((int) CONFIG_PARAM_VERSION))
{
DebugMessage(M64MSG_WARNING, "Incompatible version %.2f in 'Core' config section: current is %.2f. Setting defaults.", fConfigParamsVersion, (float) CONFIG_PARAM_VERSION);
ConfigDeleteSection("Core");
ConfigOpenSection("Core", &g_CoreConfig);
bSaveConfig = 1;
}
else if ((CONFIG_PARAM_VERSION - fConfigParamsVersion) >= 0.0001f)
{
float fVersion = (float) CONFIG_PARAM_VERSION;
ConfigSetParameter(g_CoreConfig, "Version", M64TYPE_FLOAT, &fVersion);
DebugMessage(M64MSG_INFO, "Updating parameter set version in 'Core' config section to %.2f", fVersion);
bUpgrade = 1;
bSaveConfig = 1;
}
/* parameters controlling the operation of the core */
ConfigSetDefaultFloat(g_CoreConfig, "Version", (float) CONFIG_PARAM_VERSION, "Mupen64Plus Core config parameter set version number. Please don't change this version number.");
ConfigSetDefaultBool(g_CoreConfig, "OnScreenDisplay", 1, "Draw on-screen display if True, otherwise don't draw OSD");
#if defined(DYNAREC)
ConfigSetDefaultInt(g_CoreConfig, "R4300Emulator", 2, "Use Pure Interpreter if 0, Cached Interpreter if 1, or Dynamic Recompiler if 2 or more");
#else
ConfigSetDefaultInt(g_CoreConfig, "R4300Emulator", 1, "Use Pure Interpreter if 0, Cached Interpreter if 1, or Dynamic Recompiler if 2 or more");
#endif
ConfigSetDefaultBool(g_CoreConfig, "NoCompiledJump", 0, "Disable compiled jump commands in dynamic recompiler (should be set to False) ");
ConfigSetDefaultBool(g_CoreConfig, "DisableExtraMem", 0, "Disable 4MB expansion RAM pack. May be necessary for some games");
ConfigSetDefaultBool(g_CoreConfig, "EnableDebugger", 0, "Activate the R4300 debugger when ROM execution begins, if core was built with Debugger support");
ConfigSetDefaultInt(g_CoreConfig, "CountPerOp", 0, "Force number of cycles per emulated instruction.");
ConfigSetDefaultBool(g_CoreConfig, "DelaySI", 1, "Delay interrupt after DMA SI read/write");
if (bSaveConfig)
ConfigSaveSection("Core");
return 1;
}
static
bool Config_SetDefault()
{
if (ConfigOpenSection("Video-General", &g_configVideoGeneral) != M64ERR_SUCCESS) {
LOG(LOG_ERROR, "Unable to open Video-General configuration section");
return false;
}
if (ConfigOpenSection("Video-GLideN64", &g_configVideoGliden64) != M64ERR_SUCCESS) {
LOG(LOG_ERROR, "Unable to open GLideN64 configuration section");
return false;
}
config.resetToDefaults();
// Set default values for "Video-General" section, if they are not set yet. Taken from RiceVideo
m64p_error res = ConfigSetDefaultBool(g_configVideoGeneral, "Fullscreen", config.video.fullscreen, "Use fullscreen mode if True, or windowed mode if False ");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultInt(g_configVideoGeneral, "ScreenWidth", config.video.windowedWidth, "Width of output window or fullscreen width");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultInt(g_configVideoGeneral, "ScreenHeight", config.video.windowedHeight, "Height of output window or fullscreen height");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultBool(g_configVideoGeneral, "VerticalSync", config.video.verticalSync, "If true, activate the SDL_GL_SWAP_CONTROL attribute");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultInt(g_configVideoGliden64, "configVersion", CONFIG_VERSION_CURRENT, "Settings version. Don't touch it.");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultInt(g_configVideoGliden64, "MultiSampling", config.video.multisampling, "Enable/Disable MultiSampling (0=off, 2,4,8,16=quality)");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultInt(g_configVideoGliden64, "AspectRatio", config.frameBufferEmulation.aspect, "Screen aspect ratio (0=stretch, 1=force 4:3, 2=force 16:9, 3=adjust)");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultInt(g_configVideoGliden64, "BufferSwapMode", config.frameBufferEmulation.bufferSwapMode, "Swap frame buffers (0=On VI update call, 1=On VI origin change, 2=On buffer update)");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultInt(g_configVideoGliden64, "UseNativeResolutionFactor", config.frameBufferEmulation.nativeResFactor, "Frame buffer size is the factor of N64 native resolution.");
assert(res == M64ERR_SUCCESS);
//#Texture Settings
res = ConfigSetDefaultBool(g_configVideoGliden64, "bilinearMode", config.texture.bilinearMode, "Bilinear filtering mode (0=N64 3point, 1=standard)");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultBool(g_configVideoGliden64, "MaxAnisotropy", config.texture.maxAnisotropy, "Max level of Anisotropic Filtering, 0 for off");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultInt(g_configVideoGliden64, "CacheSize", config.texture.maxBytes / uMegabyte, "Size of texture cache in megabytes. Good value is VRAM*3/4");
assert(res == M64ERR_SUCCESS);
//#Emulation Settings
res = ConfigSetDefaultBool(g_configVideoGliden64, "EnableNoise", config.generalEmulation.enableNoise, "Enable color noise emulation.");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultBool(g_configVideoGliden64, "EnableLOD", config.generalEmulation.enableLOD, "Enable LOD emulation.");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultBool(g_configVideoGliden64, "EnableHWLighting", config.generalEmulation.enableHWLighting, "Enable hardware per-pixel lighting.");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultBool(g_configVideoGliden64, "EnableShadersStorage", config.generalEmulation.enableShadersStorage, "Use persistent storage for compiled shaders.");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultInt(g_configVideoGliden64, "CorrectTexrectCoords", config.generalEmulation.correctTexrectCoords, "Make texrect coordinates continuous to avoid black lines between them. (0=Off, 1=Auto, 2=Force)");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultBool(g_configVideoGliden64, "enableNativeResTexrects", config.generalEmulation.enableNativeResTexrects, "Render 2D texrects in native resolution to fix misalignment between parts of 2D image.");
assert(res == M64ERR_SUCCESS);
#ifdef ANDROID
res = ConfigSetDefaultBool(g_configVideoGliden64, "ForcePolygonOffset", config.generalEmulation.forcePolygonOffset, "If true, use polygon offset values specified below");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultFloat(g_configVideoGliden64, "PolygonOffsetFactor", config.generalEmulation.polygonOffsetFactor, "Specifies a scale factor that is used to create a variable depth offset for each polygon");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultFloat(g_configVideoGliden64, "PolygonOffsetUnits", config.generalEmulation.polygonOffsetUnits, "Is multiplied by an implementation-specific value to create a constant depth offset");
assert(res == M64ERR_SUCCESS);
#endif
//#Frame Buffer Settings:"
res = ConfigSetDefaultBool(g_configVideoGliden64, "EnableFBEmulation", config.frameBufferEmulation.enable, "Enable frame and|or depth buffer emulation.");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultBool(g_configVideoGliden64, "EnableCopyAuxiliaryToRDRAM", config.frameBufferEmulation.copyAuxToRDRAM, "Copy auxiliary buffers to RDRAM");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultBool(g_configVideoGliden64, "EnableN64DepthCompare", config.frameBufferEmulation.N64DepthCompare, "Enable N64 depth compare instead of OpenGL standard one. Experimental.");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultBool(g_configVideoGliden64, "DisableFBInfo", config.frameBufferEmulation.fbInfoDisabled, "Disable buffers read/write with FBInfo. Use for games, which do not work with FBInfo.");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultBool(g_configVideoGliden64, "FBInfoReadColorChunk", config.frameBufferEmulation.fbInfoReadColorChunk, "Read color buffer by 4kb chunks (strict follow to FBRead specification)");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultBool(g_configVideoGliden64, "FBInfoReadDepthChunk", config.frameBufferEmulation.fbInfoReadDepthChunk, "Read depth buffer by 4kb chunks (strict follow to FBRead specification)");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultInt(g_configVideoGliden64, "EnableCopyColorToRDRAM", config.frameBufferEmulation.copyToRDRAM, "Enable color buffer copy to RDRAM (0=do not copy, 1=copy in sync mode, 2=copy in async mode)");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultInt(g_configVideoGliden64, "EnableCopyDepthToRDRAM", config.frameBufferEmulation.copyDepthToRDRAM, "Enable depth buffer copy to RDRAM (0=do not copy, 1=copy from video memory, 2=use software render)");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultBool(g_configVideoGliden64, "EnableCopyColorFromRDRAM", config.frameBufferEmulation.copyFromRDRAM, "Enable color buffer copy from RDRAM.");
assert(res == M64ERR_SUCCESS);
//#Texture filter settings
res = ConfigSetDefaultInt(g_configVideoGliden64, "txFilterMode", config.textureFilter.txFilterMode, "Texture filter (0=none, 1=Smooth filtering 1, 2=Smooth filtering 2, 3=Smooth filtering 3, 4=Smooth filtering 4, 5=Sharp filtering 1, 6=Sharp filtering 2)");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultInt(g_configVideoGliden64, "txEnhancementMode", config.textureFilter.txEnhancementMode, "Texture Enhancement (0=none, 1=store as is, 2=X2, 3=X2SAI, 4=HQ2X, 5=HQ2XS, 6=LQ2X, 7=LQ2XS, 8=HQ4X, 9=2xBRZ, 10=3xBRZ, 11=4xBRZ, 12=5xBRZ), 13=6xBRZ");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultBool(g_configVideoGliden64, "txDeposterize", config.textureFilter.txDeposterize, "Deposterize texture before enhancement.");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultBool(g_configVideoGliden64, "txFilterIgnoreBG", config.textureFilter.txFilterIgnoreBG, "Don't filter background textures.");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultInt(g_configVideoGliden64, "txCacheSize", config.textureFilter.txCacheSize/uMegabyte, "Size of filtered textures cache in megabytes.");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultBool(g_configVideoGliden64, "txHiresEnable", config.textureFilter.txHiresEnable, "Use high-resolution texture packs if available.");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultBool(g_configVideoGliden64, "txHiresFullAlphaChannel", config.textureFilter.txHiresFullAlphaChannel, "Allow to use alpha channel of high-res texture fully.");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultBool(g_configVideoGliden64, "txHresAltCRC", config.textureFilter.txHresAltCRC, "Use alternative method of paletted textures CRC calculation.");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultBool(g_configVideoGliden64, "txDump", config.textureFilter.txDump, "Enable dump of loaded N64 textures.");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultBool(g_configVideoGliden64, "txCacheCompression", config.textureFilter.txCacheCompression, "Zip textures cache.");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultBool(g_configVideoGliden64, "txForce16bpp", config.textureFilter.txForce16bpp, "Force use 16bit texture formats for HD textures.");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultBool(g_configVideoGliden64, "txSaveCache", config.textureFilter.txSaveCache, "Save texture cache to hard disk.");
assert(res == M64ERR_SUCCESS);
// Convert to multibyte
char txPath[PLUGIN_PATH_SIZE * 2];
wcstombs(txPath, config.textureFilter.txPath, PLUGIN_PATH_SIZE * 2);
res = ConfigSetDefaultString(g_configVideoGliden64, "txPath", txPath, "Path to folder with hi-res texture packs.");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultString(g_configVideoGliden64, "fontName", config.font.name.c_str(), "File name of True Type Font for text messages.");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultInt(g_configVideoGliden64, "fontSize", config.font.size, "Font size.");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultString(g_configVideoGliden64, "fontColor", "B5E61D", "Font color in RGB format.");
assert(res == M64ERR_SUCCESS);
//#Bloom filter settings
res = ConfigSetDefaultBool(g_configVideoGliden64, "EnableBloom", config.bloomFilter.enable, "Enable bloom filter");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultInt(g_configVideoGliden64, "bloomThresholdLevel", config.bloomFilter.thresholdLevel, "Brightness threshold level for bloom. Values [2, 6]");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultInt(g_configVideoGliden64, "bloomBlendMode", config.bloomFilter.blendMode, "Bloom blend mode (0=Strong, 1=Mild, 2=Light)");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultInt(g_configVideoGliden64, "blurAmount", config.bloomFilter.blurAmount, "Blur radius. Values [2, 10]");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultInt(g_configVideoGliden64, "blurStrength", config.bloomFilter.blurStrength, "Blur strength. Values [10, 100]");
assert(res == M64ERR_SUCCESS);
//#Gamma correction settings
res = ConfigSetDefaultBool(g_configVideoGliden64, "ForceGammaCorrection", config.gammaCorrection.force, "Force gamma correction.");
assert(res == M64ERR_SUCCESS);
res = ConfigSetDefaultFloat(g_configVideoGliden64, "GammaCorrectionLevel", config.gammaCorrection.level, "Gamma correction level.");
assert(res == M64ERR_SUCCESS);
return ConfigSaveSection("Video-GLideN64") == M64ERR_SUCCESS;
}
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);
}
}
}
int event_set_core_defaults(void)
{
float fConfigParamsVersion;
int bSaveConfig = 0;
if (ConfigOpenSection("CoreEvents", &l_CoreEventsConfig) != M64ERR_SUCCESS || l_CoreEventsConfig == NULL)
{
DebugMessage(M64MSG_ERROR, "Failed to open CoreEvents config section.");
return 0; /* fail */
}
if (ConfigGetParameter(l_CoreEventsConfig, "Version", M64TYPE_FLOAT, &fConfigParamsVersion, sizeof(float)) != M64ERR_SUCCESS)
{
DebugMessage(M64MSG_WARNING, "No version number in 'CoreEvents' config section. Setting defaults.");
ConfigDeleteSection("CoreEvents");
ConfigOpenSection("CoreEvents", &l_CoreEventsConfig);
bSaveConfig = 1;
}
else if (((int) fConfigParamsVersion) != ((int) CONFIG_PARAM_VERSION))
{
DebugMessage(M64MSG_WARNING, "Incompatible version %.2f in 'CoreEvents' config section: current is %.2f. Setting defaults.", fConfigParamsVersion, (float) CONFIG_PARAM_VERSION);
ConfigDeleteSection("CoreEvents");
ConfigOpenSection("CoreEvents", &l_CoreEventsConfig);
bSaveConfig = 1;
}
else if ((CONFIG_PARAM_VERSION - fConfigParamsVersion) >= 0.0001f)
{
/* handle upgrades */
float fVersion = CONFIG_PARAM_VERSION;
ConfigSetParameter(l_CoreEventsConfig, "Version", M64TYPE_FLOAT, &fVersion);
DebugMessage(M64MSG_INFO, "Updating parameter set version in 'CoreEvents' config section to %.2f", fVersion);
bSaveConfig = 1;
}
ConfigSetDefaultFloat(l_CoreEventsConfig, "Version", CONFIG_PARAM_VERSION, "Mupen64Plus CoreEvents config parameter set version number. Please don't change this version number.");
/* Keyboard presses mapped to core functions */
ConfigSetDefaultInt(l_CoreEventsConfig, kbdStop, sdl_native2keysym(SDL_SCANCODE_ESCAPE), "SDL keysym for stopping the emulator");
ConfigSetDefaultInt(l_CoreEventsConfig, kbdFullscreen, sdl_native2keysym(SDL_NUM_SCANCODES), "SDL keysym for switching between fullscreen/windowed modes");
ConfigSetDefaultInt(l_CoreEventsConfig, kbdSave, sdl_native2keysym(SDL_SCANCODE_F5), "SDL keysym for saving the emulator state");
ConfigSetDefaultInt(l_CoreEventsConfig, kbdLoad, sdl_native2keysym(SDL_SCANCODE_F7), "SDL keysym for loading the emulator state");
ConfigSetDefaultInt(l_CoreEventsConfig, kbdIncrement, sdl_native2keysym(SDL_SCANCODE_UNKNOWN), "SDL keysym for advancing the save state slot");
ConfigSetDefaultInt(l_CoreEventsConfig, kbdReset, sdl_native2keysym(SDL_SCANCODE_F9), "SDL keysym for resetting the emulator");
ConfigSetDefaultInt(l_CoreEventsConfig, kbdSpeeddown, sdl_native2keysym(SDL_SCANCODE_F10), "SDL keysym for slowing down the emulator");
ConfigSetDefaultInt(l_CoreEventsConfig, kbdSpeedup, sdl_native2keysym(SDL_SCANCODE_F11), "SDL keysym for speeding up the emulator");
ConfigSetDefaultInt(l_CoreEventsConfig, kbdScreenshot, sdl_native2keysym(SDL_SCANCODE_F12), "SDL keysym for taking a screenshot");
ConfigSetDefaultInt(l_CoreEventsConfig, kbdPause, sdl_native2keysym(SDL_SCANCODE_P), "SDL keysym for pausing the emulator");
ConfigSetDefaultInt(l_CoreEventsConfig, kbdMute, sdl_native2keysym(SDL_SCANCODE_M), "SDL keysym for muting/unmuting the sound");
ConfigSetDefaultInt(l_CoreEventsConfig, kbdIncrease, sdl_native2keysym(SDL_SCANCODE_RIGHTBRACKET),"SDL keysym for increasing the volume");
ConfigSetDefaultInt(l_CoreEventsConfig, kbdDecrease, sdl_native2keysym(SDL_SCANCODE_LEFTBRACKET), "SDL keysym for decreasing the volume");
ConfigSetDefaultInt(l_CoreEventsConfig, kbdForward, sdl_native2keysym(SDL_SCANCODE_F), "SDL keysym for temporarily going really fast");
ConfigSetDefaultInt(l_CoreEventsConfig, kbdAdvance, sdl_native2keysym(SDL_SCANCODE_SLASH), "SDL keysym for advancing by one frame when paused");
ConfigSetDefaultInt(l_CoreEventsConfig, kbdGameshark, sdl_native2keysym(SDL_SCANCODE_G), "SDL keysym for pressing the game shark button");
/* Joystick events mapped to core functions */
ConfigSetDefaultString(l_CoreEventsConfig, JoyCmdName[joyStop], "", "Joystick event string for stopping the emulator");
ConfigSetDefaultString(l_CoreEventsConfig, JoyCmdName[joyFullscreen], "", "Joystick event string for switching between fullscreen/windowed modes");
ConfigSetDefaultString(l_CoreEventsConfig, JoyCmdName[joySave], "", "Joystick event string for saving the emulator state");
ConfigSetDefaultString(l_CoreEventsConfig, JoyCmdName[joyLoad], "", "Joystick event string for loading the emulator state");
ConfigSetDefaultString(l_CoreEventsConfig, JoyCmdName[joyIncrement], "", "Joystick event string for advancing the save state slot");
ConfigSetDefaultString(l_CoreEventsConfig, JoyCmdName[joyScreenshot], "", "Joystick event string for taking a screenshot");
ConfigSetDefaultString(l_CoreEventsConfig, JoyCmdName[joyPause], "", "Joystick event string for pausing the emulator");
ConfigSetDefaultString(l_CoreEventsConfig, JoyCmdName[joyMute], "", "Joystick event string for muting/unmuting the sound");
ConfigSetDefaultString(l_CoreEventsConfig, JoyCmdName[joyIncrease], "", "Joystick event string for increasing the volume");
ConfigSetDefaultString(l_CoreEventsConfig, JoyCmdName[joyDecrease], "", "Joystick event string for decreasing the volume");
ConfigSetDefaultString(l_CoreEventsConfig, JoyCmdName[joyForward], "", "Joystick event string for fast-forward");
ConfigSetDefaultString(l_CoreEventsConfig, JoyCmdName[joyGameshark], "", "Joystick event string for pressing the game shark button");
if (bSaveConfig)
ConfigSaveSection("CoreEvents");
return 1;
}
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;
}
