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 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 Config_LoadConfig() { const u32 hacks = config.generalEmulation.hacks; if (!Config_SetDefault()) { config.generalEmulation.hacks = hacks; return; } config.version = ConfigGetParamInt(g_configVideoGliden64, "configVersion"); if (config.version != CONFIG_VERSION_CURRENT) { m64p_error res = ConfigDeleteSection("Video-GLideN64"); assert(res == M64ERR_SUCCESS); ConfigSaveFile(); if (!Config_SetDefault()) { config.generalEmulation.hacks = hacks; return; } } config.video.fullscreen = ConfigGetParamBool(g_configVideoGeneral, "Fullscreen"); config.video.windowedWidth = ConfigGetParamInt(g_configVideoGeneral, "ScreenWidth"); config.video.windowedHeight = ConfigGetParamInt(g_configVideoGeneral, "ScreenHeight"); config.video.verticalSync = ConfigGetParamBool(g_configVideoGeneral, "VerticalSync"); #ifdef GL_MULTISAMPLING_SUPPORT config.video.multisampling = ConfigGetParamInt(g_configVideoGliden64, "MultiSampling"); #else config.video.multisampling = 0; #endif config.frameBufferEmulation.aspect = ConfigGetParamInt(g_configVideoGliden64, "AspectRatio"); config.frameBufferEmulation.bufferSwapMode = ConfigGetParamInt(g_configVideoGliden64, "BufferSwapMode"); config.frameBufferEmulation.nativeResFactor = ConfigGetParamInt(g_configVideoGliden64, "UseNativeResolutionFactor"); //#Texture Settings config.texture.bilinearMode = ConfigGetParamBool(g_configVideoGliden64, "bilinearMode"); config.texture.maxAnisotropy = ConfigGetParamInt(g_configVideoGliden64, "MaxAnisotropy"); config.texture.maxBytes = ConfigGetParamInt(g_configVideoGliden64, "CacheSize") * uMegabyte; //#Emulation Settings config.generalEmulation.enableNoise = ConfigGetParamBool(g_configVideoGliden64, "EnableNoise"); config.generalEmulation.enableLOD = ConfigGetParamBool(g_configVideoGliden64, "EnableLOD"); config.generalEmulation.enableHWLighting = ConfigGetParamBool(g_configVideoGliden64, "EnableHWLighting"); config.generalEmulation.enableShadersStorage = ConfigGetParamBool(g_configVideoGliden64, "EnableShadersStorage"); config.generalEmulation.correctTexrectCoords = ConfigGetParamInt(g_configVideoGliden64, "CorrectTexrectCoords"); config.generalEmulation.enableNativeResTexrects = ConfigGetParamBool(g_configVideoGliden64, "enableNativeResTexrects"); #ifdef ANDROID config.generalEmulation.forcePolygonOffset = ConfigGetParamBool(g_configVideoGliden64, "ForcePolygonOffset"); config.generalEmulation.polygonOffsetFactor = ConfigGetParamFloat(g_configVideoGliden64, "PolygonOffsetFactor"); config.generalEmulation.polygonOffsetUnits = ConfigGetParamFloat(g_configVideoGliden64, "PolygonOffsetUnits"); #endif //#Frame Buffer Settings:" config.frameBufferEmulation.enable = ConfigGetParamBool(g_configVideoGliden64, "EnableFBEmulation"); config.frameBufferEmulation.copyAuxToRDRAM = ConfigGetParamBool(g_configVideoGliden64, "EnableCopyAuxiliaryToRDRAM"); config.frameBufferEmulation.copyToRDRAM = ConfigGetParamInt(g_configVideoGliden64, "EnableCopyColorToRDRAM"); config.frameBufferEmulation.copyDepthToRDRAM = ConfigGetParamInt(g_configVideoGliden64, "EnableCopyDepthToRDRAM"); config.frameBufferEmulation.copyFromRDRAM = ConfigGetParamBool(g_configVideoGliden64, "EnableCopyColorFromRDRAM"); config.frameBufferEmulation.N64DepthCompare = ConfigGetParamBool(g_configVideoGliden64, "EnableN64DepthCompare"); config.frameBufferEmulation.fbInfoDisabled = ConfigGetParamBool(g_configVideoGliden64, "DisableFBInfo"); config.frameBufferEmulation.fbInfoReadColorChunk = ConfigGetParamBool(g_configVideoGliden64, "FBInfoReadColorChunk"); config.frameBufferEmulation.fbInfoReadDepthChunk = ConfigGetParamBool(g_configVideoGliden64, "FBInfoReadDepthChunk"); //#Texture filter settings config.textureFilter.txFilterMode = ConfigGetParamInt(g_configVideoGliden64, "txFilterMode"); config.textureFilter.txEnhancementMode = ConfigGetParamInt(g_configVideoGliden64, "txEnhancementMode"); config.textureFilter.txDeposterize = ConfigGetParamInt(g_configVideoGliden64, "txDeposterize"); config.textureFilter.txFilterIgnoreBG = ConfigGetParamBool(g_configVideoGliden64, "txFilterIgnoreBG"); config.textureFilter.txCacheSize = ConfigGetParamInt(g_configVideoGliden64, "txCacheSize") * uMegabyte; config.textureFilter.txHiresEnable = ConfigGetParamBool(g_configVideoGliden64, "txHiresEnable"); config.textureFilter.txHiresFullAlphaChannel = ConfigGetParamBool(g_configVideoGliden64, "txHiresFullAlphaChannel"); config.textureFilter.txHresAltCRC = ConfigGetParamBool(g_configVideoGliden64, "txHresAltCRC"); config.textureFilter.txDump = ConfigGetParamBool(g_configVideoGliden64, "txDump"); config.textureFilter.txForce16bpp = ConfigGetParamBool(g_configVideoGliden64, "txForce16bpp"); config.textureFilter.txCacheCompression = ConfigGetParamBool(g_configVideoGliden64, "txCacheCompression"); config.textureFilter.txSaveCache = ConfigGetParamBool(g_configVideoGliden64, "txSaveCache"); ::mbstowcs(config.textureFilter.txPath, ConfigGetParamString(g_configVideoGliden64, "txPath"), PLUGIN_PATH_SIZE); //#Font settings config.font.name = ConfigGetParamString(g_configVideoGliden64, "fontName"); if (config.font.name.empty()) config.font.name = "arial.ttf"; char buf[16]; sprintf(buf, "0x%s", ConfigGetParamString(g_configVideoGliden64, "fontColor")); long int uColor = strtol(buf, nullptr, 16); if (uColor != 0) { config.font.color[0] = _SHIFTR(uColor, 16, 8); config.font.color[1] = _SHIFTR(uColor, 8, 8); config.font.color[2] = _SHIFTR(uColor, 0, 8); config.font.color[3] = 0xFF; config.font.colorf[0] = _FIXED2FLOAT(config.font.color[0], 8); config.font.colorf[1] = _FIXED2FLOAT(config.font.color[1], 8); config.font.colorf[2] = _FIXED2FLOAT(config.font.color[2], 8); config.font.colorf[3] = 1.0f; } config.font.size = ConfigGetParamInt(g_configVideoGliden64, "fontSize"); if (config.font.size == 0) config.font.size = 30; //#Bloom filter settings config.bloomFilter.enable = ConfigGetParamBool(g_configVideoGliden64, "EnableBloom"); config.bloomFilter.thresholdLevel = ConfigGetParamInt(g_configVideoGliden64, "bloomThresholdLevel"); config.bloomFilter.blendMode = ConfigGetParamInt(g_configVideoGliden64, "bloomBlendMode"); config.bloomFilter.blurAmount = ConfigGetParamInt(g_configVideoGliden64, "blurAmount"); config.bloomFilter.blurStrength = ConfigGetParamInt(g_configVideoGliden64, "blurStrength"); //#Gamma correction settings config.gammaCorrection.force = ConfigGetParamBool(g_configVideoGliden64, "ForceGammaCorrection"); config.gammaCorrection.level = ConfigGetParamFloat(g_configVideoGliden64, "GammaCorrectionLevel"); config.generalEmulation.hacks = hacks; }
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); } } }
static void save_controller_config(int iCtrlIdx, const char *pccDeviceName) { m64p_handle pConfig; char SectionName[32], Param[32], ParamString[128]; int j; /* Delete the configuration section for this controller, so we can use SetDefaults and save the help comments also */ sprintf(SectionName, "Input-SDL-Control%i", iCtrlIdx + 1); ConfigDeleteSection(SectionName); /* Open the configuration section for this controller (create a new one) */ if (ConfigOpenSection(SectionName, &pConfig) != M64ERR_SUCCESS) { DebugMessage(M64MSG_ERROR, "Couldn't open config section '%s'", SectionName); return; } /* save the general controller parameters */ ConfigSetDefaultFloat(pConfig, "version", CONFIG_VERSION, "Mupen64Plus SDL Input Plugin config parameter version number. Please don't change this version number."); ConfigSetDefaultBool(pConfig, "plugged", controller[iCtrlIdx].control->Present, "Specifies whether this controller is 'plugged in' to the simulated N64"); ConfigSetDefaultInt(pConfig, "plugin", controller[iCtrlIdx].control->Plugin, "Specifies which type of expansion pak is in the controller: 1=None, 2=Mem pak, 5=Rumble pak"); ConfigSetDefaultBool(pConfig, "mouse", controller[iCtrlIdx].mouse, "If True, then mouse buttons may be used with this controller"); ConfigSetDefaultInt(pConfig, "device", controller[iCtrlIdx].device, "Specifies which joystick is bound to this controller: -2=Keyboard/mouse, -1=Auto config, 0 or more= SDL Joystick number"); ConfigSetDefaultString(pConfig, "name", pccDeviceName, "SDL joystick name (name check disabled if this is empty string)"); sprintf(Param, "%.2f,%.2f", controller[iCtrlIdx].mouse_sens[0], controller[iCtrlIdx].mouse_sens[1]); ConfigSetDefaultString(pConfig, "MouseSensitivity", Param, "Scaling factor for mouse movements. For X, Y axes."); sprintf(Param, "%i,%i", controller[iCtrlIdx].axis_deadzone[0], controller[iCtrlIdx].axis_deadzone[1]); ConfigSetDefaultString(pConfig, "AnalogDeadzone", Param, "The minimum absolute value of the SDL analog joystick axis to move the N64 controller axis value from 0. For X, Y axes."); sprintf(Param, "%i,%i", controller[iCtrlIdx].axis_peak[0], controller[iCtrlIdx].axis_peak[1]); ConfigSetDefaultString(pConfig, "AnalogPeak", Param, "An absolute value of the SDL joystick axis >= AnalogPeak will saturate the N64 controller axis value (at 80). For X, Y axes. For each axis, this must be greater than the corresponding AnalogDeadzone value"); /* save configuration for all the digital buttons */ for (j = 0; j < X_AXIS; j++ ) { const char *Help; int len = 0; ParamString[0] = 0; if (controller[iCtrlIdx].button[j].key > 0) { sprintf(Param, "key(%i) ", controller[iCtrlIdx].button[j].key); strcat(ParamString, Param); } if (controller[iCtrlIdx].button[j].button >= 0) { sprintf(Param, "button(%i) ", controller[iCtrlIdx].button[j].button); strcat(ParamString, Param); } if (controller[iCtrlIdx].button[j].axis >= 0) { if (controller[iCtrlIdx].button[j].axis_deadzone >= 0) sprintf(Param, "axis(%i%c,%i) ", controller[iCtrlIdx].button[j].axis, (controller[iCtrlIdx].button[j].axis_dir == -1) ? '-' : '+', controller[iCtrlIdx].button[j].axis_deadzone); else sprintf(Param, "axis(%i%c) ", controller[iCtrlIdx].button[j].axis, (controller[iCtrlIdx].button[j].axis_dir == -1) ? '-' : '+'); strcat(ParamString, Param); } if (controller[iCtrlIdx].button[j].hat >= 0) { sprintf(Param, "hat(%i %s) ", controller[iCtrlIdx].button[j].hat, HAT_POS_NAME(controller[iCtrlIdx].button[j].hat_pos)); strcat(ParamString, Param); } if (controller[iCtrlIdx].button[j].mouse >= 0) { sprintf(Param, "mouse(%i) ", controller[iCtrlIdx].button[j].mouse); strcat(ParamString, Param); } if (j == 0) Help = "Digital button configuration mappings"; else Help = NULL; /* if last character is a space, chop it off */ len = strlen(ParamString); if (len > 0 && ParamString[len-1] == ' ') ParamString[len-1] = 0; ConfigSetDefaultString(pConfig, button_names[j], ParamString, Help); } /* save configuration for the 2 analog axes */ for (j = 0; j < 2; j++ ) { const char *Help; int len = 0; ParamString[0] = 0; if (controller[iCtrlIdx].axis[j].key_a > 0 && controller[iCtrlIdx].axis[j].key_b > 0) { sprintf(Param, "key(%i,%i) ", controller[iCtrlIdx].axis[j].key_a, controller[iCtrlIdx].axis[j].key_b); strcat(ParamString, Param); } if (controller[iCtrlIdx].axis[j].button_a >= 0 && controller[iCtrlIdx].axis[j].button_b >= 0) { sprintf(Param, "button(%i,%i) ", controller[iCtrlIdx].axis[j].button_a, controller[iCtrlIdx].axis[j].button_b); strcat(ParamString, Param); } if (controller[iCtrlIdx].axis[j].axis_a >= 0 && controller[iCtrlIdx].axis[j].axis_b >= 0) { sprintf(Param, "axis(%i%c,%i%c) ", controller[iCtrlIdx].axis[j].axis_a, (controller[iCtrlIdx].axis[j].axis_dir_a <= 0) ? '-' : '+', controller[iCtrlIdx].axis[j].axis_b, (controller[iCtrlIdx].axis[j].axis_dir_b <= 0) ? '-' : '+' ); strcat(ParamString, Param); } if (controller[iCtrlIdx].axis[j].hat >= 0) { sprintf(Param, "hat(%i %s %s) ", controller[iCtrlIdx].axis[j].hat, HAT_POS_NAME(controller[iCtrlIdx].axis[j].hat_pos_a), HAT_POS_NAME(controller[iCtrlIdx].axis[j].hat_pos_b)); strcat(ParamString, Param); } if (j == 0) Help = "Analog axis configuration mappings"; else Help = NULL; /* if last character is a space, chop it off */ len = strlen(ParamString); if (len > 0 && ParamString[len-1] == ' ') ParamString[len-1] = 0; ConfigSetDefaultString(pConfig, button_names[X_AXIS + j], ParamString, Help); } }
static int load_controller_config(const char *SectionName, int i, int bIsAutoconfig) { m64p_handle pConfig; char input_str[256], value1_str[16], value2_str[16]; const char *config_ptr; int j; /* Open the configuration section for this controller */ if (ConfigOpenSection(SectionName, &pConfig) != M64ERR_SUCCESS) { DebugMessage(M64MSG_ERROR, "Couldn't open config section '%s'", SectionName); return 0; } /* Check version number, and if it doesn't match: delete the config section and return with error */ if (!bIsAutoconfig) { float fVersion = 0.0f; if (ConfigGetParameter(pConfig, "version", M64TYPE_FLOAT, &fVersion, sizeof(float)) != M64ERR_SUCCESS) { ConfigDeleteSection(SectionName); return -1; } if (((int) fVersion) != ((int) CONFIG_VERSION)) { DebugMessage(M64MSG_WARNING, "Incompatible version %.2f in config section '%s': current is %.2f. Clearing.", fVersion, SectionName, (float) CONFIG_VERSION); ConfigDeleteSection(SectionName); return -1; } } /* check for the required parameters */ if (ConfigGetParameter(pConfig, "plugged", M64TYPE_BOOL, &controller[i].control->Present, sizeof(int)) != M64ERR_SUCCESS) return -1; if (ConfigGetParameter(pConfig, "plugin", M64TYPE_INT, &controller[i].control->Plugin, sizeof(int)) != M64ERR_SUCCESS) return -1; if (ConfigGetParameter(pConfig, "device", M64TYPE_INT, &controller[i].device, sizeof(int)) != M64ERR_SUCCESS) return -1; /* Name validation only applies to stored configurations (not auto-configs) */ if (!bIsAutoconfig) { char device_name[256]; if (ConfigGetParameter(pConfig, "name", M64TYPE_STRING, device_name, 256) != M64ERR_SUCCESS) device_name[0] = 0; if (controller[i].device == DEVICE_NOT_JOYSTICK) { /* do not load automatically generated keyboard config that was stored to disk (prefer any joysticks attached) */ if (strcmp(device_name, "AutoKeyboard") == 0) return -2; } else if (controller[i].device >= 0 && device_name[0] != 0) { /* check that the SDL device name matches the name stored in the config section */ const char *sdl_name = get_sdl_joystick_name(controller[i].device); if (sdl_name == NULL || strncmp(device_name, sdl_name, 255) != 0) { DebugMessage(M64MSG_WARNING, "N64 Controller #%i: SDL joystick name '%s' doesn't match stored configuration name '%s'", i + 1, sdl_name, device_name); return -3; } } } /* then do the optional parameters */ ConfigGetParameter(pConfig, "mouse", M64TYPE_BOOL, &controller[i].mouse, sizeof(int)); if (ConfigGetParameter(pConfig, "MouseSensitivity", M64TYPE_STRING, input_str, 256) == M64ERR_SUCCESS) { if (sscanf(input_str, "%f,%f", &controller[i].mouse_sens[0], &controller[i].mouse_sens[1]) != 2) DebugMessage(M64MSG_WARNING, "parsing error in MouseSensitivity parameter for controller %i", i + 1); } if (ConfigGetParameter(pConfig, "AnalogDeadzone", M64TYPE_STRING, input_str, 256) == M64ERR_SUCCESS) { if (sscanf(input_str, "%i,%i", &controller[i].axis_deadzone[0], &controller[i].axis_deadzone[1]) != 2) DebugMessage(M64MSG_WARNING, "parsing error in AnalogDeadzone parameter for controller %i", i + 1); } if (ConfigGetParameter(pConfig, "AnalogPeak", M64TYPE_STRING, input_str, 256) == M64ERR_SUCCESS) { if (sscanf(input_str, "%i,%i", &controller[i].axis_peak[0], &controller[i].axis_peak[1]) != 2) DebugMessage(M64MSG_WARNING, "parsing error in AnalogPeak parameter for controller %i", i + 1); } /* load configuration for all the digital buttons */ for (j = 0; j < X_AXIS; j++) { if (ConfigGetParameter(pConfig, button_names[j], M64TYPE_STRING, input_str, 256) != M64ERR_SUCCESS) { DebugMessage(M64MSG_WARNING, "missing config key '%s' for controller %i button %i", button_names[j], i+1, j); continue; } if ((config_ptr = strstr(input_str, "key")) != NULL) if (sscanf(config_ptr, "key(%i)", (int *) &controller[i].button[j].key) != 1) DebugMessage(M64MSG_WARNING, "parsing error in key() parameter of button '%s' for controller %i", button_names[j], i + 1); if ((config_ptr = strstr(input_str, "button")) != NULL) if (sscanf(config_ptr, "button(%i)", &controller[i].button[j].button) != 1) DebugMessage(M64MSG_WARNING, "parsing error in button() parameter of button '%s' for controller %i", button_names[j], i + 1); if ((config_ptr = strstr(input_str, "axis")) != NULL) { char chAxisDir; if (sscanf(config_ptr, "axis(%d%c,%d", &controller[i].button[j].axis, &chAxisDir, &controller[i].button[j].axis_deadzone) != 3 && sscanf(config_ptr, "axis(%i%c", &controller[i].button[j].axis, &chAxisDir) != 2) DebugMessage(M64MSG_WARNING, "parsing error in axis() parameter of button '%s' for controller %i", button_names[j], i + 1); controller[i].button[j].axis_dir = (chAxisDir == '+' ? 1 : (chAxisDir == '-' ? -1 : 0)); } if ((config_ptr = strstr(input_str, "hat")) != NULL) { char *lastchar = NULL; if (sscanf(config_ptr, "hat(%i %15s", &controller[i].button[j].hat, value1_str) != 2) DebugMessage(M64MSG_WARNING, "parsing error in hat() parameter of button '%s' for controller %i", button_names[j], i + 1); value1_str[15] = 0; /* chop off the last character of value1_str if it is the closing parenthesis */ lastchar = &value1_str[strlen(value1_str) - 1]; if (lastchar > value1_str && *lastchar == ')') *lastchar = 0; controller[i].button[j].hat_pos = get_hat_pos_by_name(value1_str); } if ((config_ptr = strstr(input_str, "mouse")) != NULL) if (sscanf(config_ptr, "mouse(%i)", &controller[i].button[j].mouse) != 1) DebugMessage(M64MSG_WARNING, "parsing error in mouse() parameter of button '%s' for controller %i", button_names[j], i + 1); } /* load configuration for the 2 analog joystick axes */ for (j = X_AXIS; j <= Y_AXIS; j++) { int axis_idx = j - X_AXIS; if (ConfigGetParameter(pConfig, button_names[j], M64TYPE_STRING, input_str, 256) != M64ERR_SUCCESS) { DebugMessage(M64MSG_WARNING, "missing config key '%s' for controller %i axis %i", button_names[j], i+1, axis_idx); continue; } if ((config_ptr = strstr(input_str, "key")) != NULL) if (sscanf(config_ptr, "key(%i,%i)", (int *) &controller[i].axis[axis_idx].key_a, (int *) &controller[i].axis[axis_idx].key_b) != 2) DebugMessage(M64MSG_WARNING, "parsing error in key() parameter of axis '%s' for controller %i", button_names[j], i + 1); if ((config_ptr = strstr(input_str, "button")) != NULL) if (sscanf(config_ptr, "button(%i,%i)", &controller[i].axis[axis_idx].button_a, &controller[i].axis[axis_idx].button_b) != 2) DebugMessage(M64MSG_WARNING, "parsing error in button() parameter of axis '%s' for controller %i", button_names[j], i + 1); if ((config_ptr = strstr(input_str, "axis")) != NULL) { char chAxisDir1, chAxisDir2; if (sscanf(config_ptr, "axis(%i%c,%i%c)", &controller[i].axis[axis_idx].axis_a, &chAxisDir1, &controller[i].axis[axis_idx].axis_b, &chAxisDir2) != 4) DebugMessage(M64MSG_WARNING, "parsing error in axis() parameter of axis '%s' for controller %i", button_names[j], i + 1); controller[i].axis[axis_idx].axis_dir_a = (chAxisDir1 == '+' ? 1 : (chAxisDir1 == '-' ? -1 : 0)); controller[i].axis[axis_idx].axis_dir_b = (chAxisDir2 == '+' ? 1 : (chAxisDir2 == '-' ? -1 : 0)); } if ((config_ptr = strstr(input_str, "hat")) != NULL) { char *lastchar = NULL; if (sscanf(config_ptr, "hat(%i %15s %15s", &controller[i].axis[axis_idx].hat, value1_str, value2_str) != 3) DebugMessage(M64MSG_WARNING, "parsing error in hat() parameter of axis '%s' for controller %i", button_names[j], i + 1); value1_str[15] = value2_str[15] = 0; /* chop off the last character of value2_str if it is the closing parenthesis */ lastchar = &value2_str[strlen(value2_str) - 1]; if (lastchar > value2_str && *lastchar == ')') *lastchar = 0; controller[i].axis[axis_idx].hat_pos_a = get_hat_pos_by_name(value1_str); controller[i].axis[axis_idx].hat_pos_b = get_hat_pos_by_name(value2_str); } } return 1; }
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; }
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); } } }
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; }