mirror of
https://github.com/SourMesen/Mesen-S.git
synced 2024-05-23 06:37:27 -04:00
356 lines
8.5 KiB
C++
356 lines
8.5 KiB
C++
#include "stdafx.h"
|
|
#include <random>
|
|
#include "EmuSettings.h"
|
|
#include "KeyManager.h"
|
|
#include "MessageManager.h"
|
|
#include "Console.h"
|
|
#include "SpcDisUtils.h"
|
|
#include "NotificationManager.h"
|
|
#include "../Utilities/FolderUtilities.h"
|
|
|
|
EmuSettings::EmuSettings(Console* console)
|
|
{
|
|
_console = console;
|
|
_flags = 0;
|
|
_debuggerFlags = 0;
|
|
_inputConfigVersion = 0;
|
|
|
|
std::random_device rd;
|
|
_mt = std::mt19937(rd());
|
|
}
|
|
|
|
uint32_t EmuSettings::GetVersion()
|
|
{
|
|
//Version 0.4.0
|
|
uint16_t major = 0;
|
|
uint8_t minor = 4;
|
|
uint8_t revision = 0;
|
|
return (major << 16) | (minor << 8) | revision;
|
|
}
|
|
|
|
string EmuSettings::GetVersionString()
|
|
{
|
|
uint32_t version = GetVersion();
|
|
return std::to_string(version >> 16) + "." + std::to_string((version >> 8) & 0xFF) + "." + std::to_string(version & 0xFF);
|
|
}
|
|
|
|
void EmuSettings::ProcessString(string & str, const char ** strPointer)
|
|
{
|
|
//Make a copy of the string and keep it (the original pointer will not be valid after the call is over)
|
|
if(*strPointer) {
|
|
str = *strPointer;
|
|
} else {
|
|
str.clear();
|
|
}
|
|
*strPointer = str.c_str();
|
|
}
|
|
|
|
void EmuSettings::SetVideoConfig(VideoConfig config)
|
|
{
|
|
_video = config;
|
|
}
|
|
|
|
VideoConfig EmuSettings::GetVideoConfig()
|
|
{
|
|
return _video;
|
|
}
|
|
|
|
void EmuSettings::SetAudioConfig(AudioConfig config)
|
|
{
|
|
ProcessString(_audioDevice, &config.AudioDevice);
|
|
|
|
_audio = config;
|
|
}
|
|
|
|
AudioConfig EmuSettings::GetAudioConfig()
|
|
{
|
|
return _audio;
|
|
}
|
|
|
|
void EmuSettings::SetInputConfig(InputConfig config)
|
|
{
|
|
bool controllersChanged = false;
|
|
for(int i = 0; i < 5; i++) {
|
|
controllersChanged |= _input.Controllers[i].Type != config.Controllers[i].Type;
|
|
}
|
|
|
|
_input = config;
|
|
_inputConfigVersion++;
|
|
|
|
if(controllersChanged) {
|
|
//Used by net play
|
|
_console->GetNotificationManager()->SendNotification(ConsoleNotificationType::ConfigChanged);
|
|
}
|
|
}
|
|
|
|
InputConfig EmuSettings::GetInputConfig()
|
|
{
|
|
if(CheckFlag(EmulationFlags::GameboyMode)) {
|
|
if(_input.Controllers[0].Type != ControllerType::SnesController) {
|
|
//Force SNES controller for P1 for gameboy-only mode
|
|
InputConfig input = _input;
|
|
input.Controllers[0].Type = ControllerType::SnesController;
|
|
SetInputConfig(input);
|
|
}
|
|
}
|
|
return _input;
|
|
}
|
|
|
|
uint32_t EmuSettings::GetInputConfigVersion()
|
|
{
|
|
return _inputConfigVersion;
|
|
}
|
|
|
|
void EmuSettings::SetEmulationConfig(EmulationConfig config)
|
|
{
|
|
bool prevOverclockEnabled = _emulation.PpuExtraScanlinesAfterNmi > 0 || _emulation.PpuExtraScanlinesBeforeNmi > 0 || _emulation.GsuClockSpeed > 100;
|
|
bool overclockEnabled = config.PpuExtraScanlinesAfterNmi > 0 || config.PpuExtraScanlinesBeforeNmi > 0 || config.GsuClockSpeed > 100;
|
|
_emulation = config;
|
|
|
|
if(prevOverclockEnabled != overclockEnabled) {
|
|
if(overclockEnabled) {
|
|
MessageManager::DisplayMessage("Overclock", "OverclockEnabled");
|
|
} else {
|
|
MessageManager::DisplayMessage("Overclock", "OverclockDisabled");
|
|
}
|
|
|
|
//Used by net play
|
|
_console->GetNotificationManager()->SendNotification(ConsoleNotificationType::ConfigChanged);
|
|
}
|
|
}
|
|
|
|
EmulationConfig EmuSettings::GetEmulationConfig()
|
|
{
|
|
return _emulation;
|
|
}
|
|
|
|
void EmuSettings::SetGameboyConfig(GameboyConfig config)
|
|
{
|
|
_gameboy = config;
|
|
}
|
|
|
|
GameboyConfig EmuSettings::GetGameboyConfig()
|
|
{
|
|
return _gameboy;
|
|
}
|
|
|
|
void EmuSettings::SetPreferences(PreferencesConfig config)
|
|
{
|
|
ProcessString(_saveFolder, &config.SaveFolderOverride);
|
|
ProcessString(_saveStateFolder, &config.SaveStateFolderOverride);
|
|
ProcessString(_screenshotFolder, &config.ScreenshotFolderOverride);
|
|
|
|
MessageManager::SetOsdState(!config.DisableOsd);
|
|
|
|
FolderUtilities::SetFolderOverrides(
|
|
_saveFolder,
|
|
_saveStateFolder,
|
|
_screenshotFolder,
|
|
""
|
|
);
|
|
|
|
_preferences = config;
|
|
}
|
|
|
|
PreferencesConfig EmuSettings::GetPreferences()
|
|
{
|
|
return _preferences;
|
|
}
|
|
|
|
void EmuSettings::ClearShortcutKeys()
|
|
{
|
|
_emulatorKeys[0].clear();
|
|
_emulatorKeys[1].clear();
|
|
_emulatorKeys[2].clear();
|
|
_shortcutSupersets[0].clear();
|
|
_shortcutSupersets[1].clear();
|
|
_shortcutSupersets[2].clear();
|
|
|
|
//Add Alt-F4 as a fake shortcut to prevent Alt-F4 from triggering Alt or F4 key bindings. (e.g load save state 4)
|
|
KeyCombination keyComb;
|
|
keyComb.Key1 = KeyManager::GetKeyCode("Alt");
|
|
keyComb.Key2 = KeyManager::GetKeyCode("F4");
|
|
SetShortcutKey(EmulatorShortcut::Exit, keyComb, 2);
|
|
}
|
|
|
|
void EmuSettings::SetShortcutKey(EmulatorShortcut shortcut, KeyCombination keyCombination, int keySetIndex)
|
|
{
|
|
_emulatorKeys[keySetIndex][(uint32_t)shortcut] = keyCombination;
|
|
|
|
for(int i = 0; i < 3; i++) {
|
|
for(std::pair<const uint32_t, KeyCombination> &kvp : _emulatorKeys[i]) {
|
|
if(keyCombination.IsSubsetOf(kvp.second)) {
|
|
_shortcutSupersets[keySetIndex][(uint32_t)shortcut].push_back(kvp.second);
|
|
} else if(kvp.second.IsSubsetOf(keyCombination)) {
|
|
_shortcutSupersets[i][kvp.first].push_back(keyCombination);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void EmuSettings::SetShortcutKeys(vector<ShortcutKeyInfo> shortcuts)
|
|
{
|
|
ClearShortcutKeys();
|
|
|
|
for(ShortcutKeyInfo &shortcut : shortcuts) {
|
|
if(_emulatorKeys[0][(uint32_t)shortcut.Shortcut].GetKeys().empty()) {
|
|
SetShortcutKey(shortcut.Shortcut, shortcut.Keys, 0);
|
|
} else {
|
|
SetShortcutKey(shortcut.Shortcut, shortcut.Keys, 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
KeyCombination EmuSettings::GetShortcutKey(EmulatorShortcut shortcut, int keySetIndex)
|
|
{
|
|
auto result = _emulatorKeys[keySetIndex].find((int)shortcut);
|
|
if(result != _emulatorKeys[keySetIndex].end()) {
|
|
return result->second;
|
|
}
|
|
return {};
|
|
}
|
|
|
|
vector<KeyCombination> EmuSettings::GetShortcutSupersets(EmulatorShortcut shortcut, int keySetIndex)
|
|
{
|
|
return _shortcutSupersets[keySetIndex][(uint32_t)shortcut];
|
|
}
|
|
|
|
OverscanDimensions EmuSettings::GetOverscan()
|
|
{
|
|
OverscanDimensions overscan;
|
|
if(CheckFlag(EmulationFlags::GameboyMode)) {
|
|
//Force overscan values for gameboy-only mode (not SGB)
|
|
overscan.Left = 0;
|
|
overscan.Right = 256 - 160;
|
|
overscan.Top = 0;
|
|
overscan.Bottom = 239 - 144;
|
|
} else {
|
|
overscan.Left = _video.OverscanLeft;
|
|
overscan.Right = _video.OverscanRight;
|
|
overscan.Top = _video.OverscanTop;
|
|
overscan.Bottom = _video.OverscanBottom;
|
|
}
|
|
return overscan;
|
|
}
|
|
|
|
uint32_t EmuSettings::GetRewindBufferSize()
|
|
{
|
|
return _preferences.RewindBufferSize;
|
|
}
|
|
|
|
uint32_t EmuSettings::GetEmulationSpeed()
|
|
{
|
|
if(CheckFlag(EmulationFlags::MaximumSpeed)) {
|
|
return 0;
|
|
} else if(CheckFlag(EmulationFlags::Turbo)) {
|
|
return _emulation.TurboSpeed;
|
|
} else if(CheckFlag(EmulationFlags::Rewind)) {
|
|
return _emulation.RewindSpeed;
|
|
} else {
|
|
return _emulation.EmulationSpeed;
|
|
}
|
|
}
|
|
|
|
double EmuSettings::GetAspectRatio(ConsoleRegion region)
|
|
{
|
|
switch(_video.AspectRatio) {
|
|
case VideoAspectRatio::NoStretching: return 0.0;
|
|
case VideoAspectRatio::Auto: return region == ConsoleRegion::Pal ? (11.0 / 8.0) : (8.0 / 7.0);
|
|
case VideoAspectRatio::NTSC: return 8.0 / 7.0;
|
|
case VideoAspectRatio::PAL: return 11.0 / 8.0;
|
|
case VideoAspectRatio::Standard: return 4.0 / 3.0;
|
|
case VideoAspectRatio::Widescreen: return 16.0 / 9.0;
|
|
case VideoAspectRatio::Custom: return _video.CustomAspectRatio;
|
|
}
|
|
return 0.0;
|
|
}
|
|
|
|
void EmuSettings::SetFlag(EmulationFlags flag)
|
|
{
|
|
if((_flags & (int)flag) == 0) {
|
|
_flags |= (int)flag;
|
|
}
|
|
}
|
|
|
|
void EmuSettings::SetFlagState(EmulationFlags flag, bool enabled)
|
|
{
|
|
if(enabled) {
|
|
SetFlag(flag);
|
|
} else {
|
|
ClearFlag(flag);
|
|
}
|
|
}
|
|
|
|
void EmuSettings::ClearFlag(EmulationFlags flag)
|
|
{
|
|
if((_flags & (int)flag) != 0) {
|
|
_flags &= ~(int)flag;
|
|
}
|
|
}
|
|
|
|
bool EmuSettings::CheckFlag(EmulationFlags flag)
|
|
{
|
|
return (_flags & (int)flag) != 0;
|
|
}
|
|
|
|
void EmuSettings::SetDebuggerFlag(DebuggerFlags flag, bool enabled)
|
|
{
|
|
if(enabled) {
|
|
if((_debuggerFlags & (int)flag) == 0) {
|
|
_debuggerFlags |= (int)flag;
|
|
}
|
|
} else {
|
|
if((_debuggerFlags & (int)flag) != 0) {
|
|
_debuggerFlags &= ~(int)flag;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool EmuSettings::CheckDebuggerFlag(DebuggerFlags flag)
|
|
{
|
|
return (_debuggerFlags & (int)flag) != 0;
|
|
}
|
|
|
|
void EmuSettings::InitializeRam(void* data, uint32_t length)
|
|
{
|
|
switch(_emulation.RamPowerOnState) {
|
|
default:
|
|
case RamState::AllZeros: memset(data, 0, length); break;
|
|
case RamState::AllOnes: memset(data, 0xFF, length); break;
|
|
case RamState::Random:
|
|
std::uniform_int_distribution<> dist(0, 255);
|
|
for(uint32_t i = 0; i < length; i++) {
|
|
((uint8_t*)data)[i] = dist(_mt);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
int EmuSettings::GetRandomValue(int maxValue)
|
|
{
|
|
std::uniform_int_distribution<> dist(0, maxValue);
|
|
return dist(_mt);
|
|
}
|
|
|
|
bool EmuSettings::GetRandomBool()
|
|
{
|
|
return GetRandomValue(1) == 1;
|
|
}
|
|
|
|
bool EmuSettings::IsInputEnabled()
|
|
{
|
|
return !CheckFlag(EmulationFlags::InBackground) || _preferences.AllowBackgroundInput;
|
|
}
|
|
|
|
double EmuSettings::GetControllerDeadzoneRatio()
|
|
{
|
|
switch(_input.ControllerDeadzoneSize) {
|
|
case 0: return 0.5;
|
|
case 1: return 0.75;
|
|
case 2: return 1;
|
|
case 3: return 1.25;
|
|
case 4: return 1.5;
|
|
}
|
|
return 1;
|
|
}
|