CoCalc -- Config.cpp

GitHub Repository: hrydgard/ppsspp
Path: blob/master/Core/Config.cpp
³¹⁸⁵ views
1
// Copyright (c) 2012- PPSSPP Project.
2

3
// This program is free software: you can redistribute it and/or modify
4
// it under the terms of the GNU General Public License as published by
5
// the Free Software Foundation, version 2.0 or later versions.
6

7
// This program is distributed in the hope that it will be useful,
8
// but WITHOUT ANY WARRANTY; without even the implied warranty of
9
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10
// GNU General Public License 2.0 for more details.
11

12
// A copy of the GPL 2.0 should have been included with the program.
13
// If not, see http://www.gnu.org/licenses/
14

15
// Official git repository and contact information can be found at
16
// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
17

18
#include <algorithm>
19
#include <cstdlib>
20
#include <ctime>
21
#include <mutex>
22
#include <set>
23
#include <sstream>
24
#include <thread>
25

26
#include "ppsspp_config.h"
27

28
#include "Common/GPU/OpenGL/GLFeatures.h"
29
#include "Common/Net/HTTPClient.h"
30
#include "Common/Net/URL.h"
31

32
#include "Common/Log.h"
33
#include "Common/TimeUtil.h"
34
#include "Common/Thread/ThreadUtil.h"
35
#include "Common/Data/Format/IniFile.h"
36
#include "Common/Data/Format/JSONReader.h"
37
#include "Common/Data/Text/I18n.h"
38
#include "Common/Data/Text/Parsers.h"
39
#include "Common/CPUDetect.h"
40
#include "Common/File/FileUtil.h"
41
#include "Common/File/VFS/VFS.h"
42
#include "Common/Log/LogManager.h"
43
#include "Common/Math/CrossSIMD.h"
44
#include "Common/OSVersion.h"
45
#include "Common/System/Display.h"
46
#include "Common/System/System.h"
47
#include "Common/StringUtils.h"
48
#include "Common/Thread/ThreadUtil.h"
49
#include "Common/GPU/Vulkan/VulkanLoader.h"
50
#include "Common/VR/PPSSPPVR.h"
51
#include "Common/System/OSD.h"
52
#include "Common/System/Request.h"
53
#include "Core/Config.h"
54
#include "Core/ConfigSettings.h"
55
#include "Core/ConfigValues.h"
56
#include "Core/KeyMap.h"
57
#include "Core/System.h"
58
#include "Core/HLE/sceUtility.h"
59
#include "Core/Instance.h"
60
#include "Core/Util/RecentFiles.h"
61

62
#include "GPU/Common/FramebufferManagerCommon.h"
63

64
// TODO: Find a better place for this.
65
http::RequestManager g_DownloadManager;
66

67
Config g_Config;
68

69
static bool jitForcedOff;
70

71
#ifdef _DEBUG
72
static const char * const logSectionName = "LogDebug";
73
#else
74
static const char * const logSectionName = "Log";
75
#endif
76

77
bool TryUpdateSavedPath(Path *path);
78

79
std::string GPUBackendToString(GPUBackend backend) {
80
	switch (backend) {
81
	case GPUBackend::OPENGL:
82
		return "OPENGL";
83
	case GPUBackend::DIRECT3D11:
84
		return "DIRECT3D11";
85
	case GPUBackend::VULKAN:
86
		return "VULKAN";
87
	}
88
	// Intentionally not a default so we get a warning.
89
	return "INVALID";
90
}
91

92
GPUBackend GPUBackendFromString(std::string_view backend) {
93
	if (equalsNoCase(backend, "OPENGL") || backend == "0")
94
		return GPUBackend::OPENGL;
95
	if (equalsNoCase(backend, "DIRECT3D11") || backend == "2")
96
		return GPUBackend::DIRECT3D11;
97
	if (equalsNoCase(backend, "VULKAN") || backend == "3")
98
		return GPUBackend::VULKAN;
99
	return GPUBackend::OPENGL;
100
}
101

102
std::string DefaultLangRegion() {
103
	// Unfortunate default.  There's no need to use bFirstRun, since this is only a default.
104
	static std::string defaultLangRegion = "en_US";
105
	std::string langRegion = System_GetProperty(SYSPROP_LANGREGION);
106
	if (g_i18nrepo.IniExists(langRegion)) {
107
		defaultLangRegion = langRegion;
108
	} else if (langRegion.length() >= 3) {
109
		// Don't give up.  Let's try a fuzzy match - so nl_BE can match nl_NL.
110
		IniFile mapping;
111
		mapping.LoadFromVFS(g_VFS, "langregion.ini");
112
		std::vector<std::string> keys;
113
		mapping.GetKeys("LangRegionNames", keys);
114

115
		for (const std::string &key : keys) {
116
			if (startsWithNoCase(key, langRegion)) {
117
				// Exact submatch, or different case.  Let's use it.
118
				defaultLangRegion = key;
119
				break;
120
			} else if (startsWithNoCase(key, langRegion.substr(0, 3))) {
121
				// Best so far.
122
				defaultLangRegion = key;
123
			}
124
		}
125
	}
126

127
	return defaultLangRegion;
128
}
129

130
static int DefaultDepthRaster() {
131
#ifdef CROSSSIMD_SLOW
132
	// No SIMD acceleration for the depth rasterizer.
133
	// Default to off.
134
	return (int)DepthRasterMode::OFF;
135
#endif
136

137
// For 64-bit ARM and x86 with SIMD, enable depth raster.
138
#if PPSSPP_ARCH(ARM64_NEON) || PPSSPP_ARCH(SSE2)
139

140
#if PPSSPP_PLATFORM(ANDROID) || PPSSPP_PLATFORM(IOS)
141
	return (int)DepthRasterMode::LOW_QUALITY;
142
#else
143
	return (int)DepthRasterMode::DEFAULT;
144
#endif
145

146
#else
147

148
	// 32-bit ARM or no SIMD, the depth raster will be too slow.
149
	return (int)DepthRasterMode::OFF;
150

151
#endif
152
}
153

154
std::string CreateRandMAC() {
155
	std::stringstream randStream;
156
	srand(time(nullptr));
157
	for (int i = 0; i < 6; i++) {
158
		u32 value = rand() % 256;
159
		if (i == 0) {
160
			// Making sure the 1st 2-bits on the 1st byte of OUI are zero to prevent issue with some games (ie. Gran Turismo)
161
			value &= 0xfc;
162
		}
163
		if (value <= 15)
164
			randStream << '0' << std::hex << value;
165
		else
166
			randStream << std::hex << value;
167
		if (i < 5) {
168
			randStream << ':'; //we need a : between every octet
169
		}
170
	}
171
	return randStream.str();
172
}
173

174
static int DefaultCpuCore() {
175
#if PPSSPP_ARCH(ARM) || PPSSPP_ARCH(ARM64) || PPSSPP_ARCH(X86) || PPSSPP_ARCH(AMD64) || PPSSPP_ARCH(RISCV64) || PPSSPP_ARCH(LOONGARCH64)
176
	if (System_GetPropertyBool(SYSPROP_CAN_JIT))
177
		return (int)CPUCore::JIT;
178
	return (int)CPUCore::IR_INTERPRETER;
179
#else
180
	return (int)CPUCore::IR_INTERPRETER;
181
#endif
182
}
183

184
static bool DefaultCodeGen() {
185
#if PPSSPP_ARCH(ARM) || PPSSPP_ARCH(ARM64) || PPSSPP_ARCH(X86) || PPSSPP_ARCH(AMD64) || PPSSPP_ARCH(RISCV64) || PPSSPP_ARCH(LOONGARCH64)
186
	return true;
187
#else
188
	return false;
189
#endif
190
}
191

192
static bool DefaultVSync() {
193
#if PPSSPP_PLATFORM(ANDROID) || PPSSPP_PLATFORM(UWP)
194
	// Previously we didn't allow turning off vsync/FIFO on Android. Let's set the default accordingly.
195
	return true;
196
#else
197
	return false;
198
#endif
199
}
200

201
static bool DefaultEnableStateUndo() {
202
#if PPSSPP_PLATFORM(ANDROID) || PPSSPP_PLATFORM(IOS)
203
	// Off on mobile to save disk space.
204
	return false;
205
#endif
206
	return true;
207
}
208

209
static float DefaultUISaturation() {
210
	return IsVREnabled() ? 1.5f : 1.0f;
211
}
212

213
static int DefaultUIScaleFactor() {
214
#if PPSSPP_PLATFORM(WINDOWS) || PPSSPP_PLATFORM(LINUX) || PPSSPP_PLATFORM(MAC)
215
	return -1;
216
#else
217
	return 0;
218
#endif
219
}
220

221
static const ConfigSetting generalSettings[] = {
222
	ConfigSetting("FirstRun", &g_Config.bFirstRun, true, CfgFlag::DEFAULT),
223
	ConfigSetting("RunCount", &g_Config.iRunCount, 0, CfgFlag::DEFAULT),
224
	ConfigSetting("Enable Logging", &g_Config.bEnableLogging, true, CfgFlag::PER_GAME),
225
	ConfigSetting("FileLogging", &g_Config.bEnableFileLogging, false, CfgFlag::PER_GAME),
226
	ConfigSetting("AutoRun", &g_Config.bAutoRun, true, CfgFlag::DEFAULT),
227
	ConfigSetting("Browse", &g_Config.bBrowse, false, CfgFlag::DEFAULT),
228
	ConfigSetting("IgnoreBadMemAccess", &g_Config.bIgnoreBadMemAccess, true, CfgFlag::DEFAULT),
229
	ConfigSetting("CurrentDirectory", &g_Config.currentDirectory, "", CfgFlag::DEFAULT),
230
	ConfigSetting("ShowDebuggerOnLoad", &g_Config.bShowDebuggerOnLoad, false, CfgFlag::DEFAULT),
231
	ConfigSetting("ShowImDebugger", &g_Config.bShowImDebugger, false, CfgFlag::DONT_SAVE),
232
	ConfigSetting("CheckForNewVersion", &g_Config.bCheckForNewVersion, true, CfgFlag::DEFAULT),
233
	ConfigSetting("Language", &g_Config.sLanguageIni, &DefaultLangRegion, CfgFlag::DEFAULT),
234
	ConfigSetting("ForceLagSync2", &g_Config.bForceLagSync, false, CfgFlag::PER_GAME),
235
	ConfigSetting("DiscordRichPresence", &g_Config.bDiscordRichPresence, false, CfgFlag::DEFAULT),
236
	ConfigSetting("UISound", &g_Config.bUISound, false, CfgFlag::DEFAULT),
237

238
	ConfigSetting("DisableHTTPS", &g_Config.bDisableHTTPS, false, CfgFlag::DONT_SAVE),
239
	ConfigSetting("AutoLoadSaveState", &g_Config.iAutoLoadSaveState, 0, CfgFlag::PER_GAME),
240
	ConfigSetting("EnableCheats", &g_Config.bEnableCheats, false, CfgFlag::PER_GAME | CfgFlag::REPORT),
241
	ConfigSetting("EnablePlugins", &g_Config.bEnablePlugins, true, CfgFlag::PER_GAME | CfgFlag::REPORT),
242
	ConfigSetting("CwCheatRefreshRate", &g_Config.iCwCheatRefreshIntervalMs, 77, CfgFlag::PER_GAME),
243
	ConfigSetting("CwCheatScrollPosition", &g_Config.fCwCheatScrollPosition, 0.0f, CfgFlag::PER_GAME),
244
	ConfigSetting("GameListScrollPosition", &g_Config.fGameListScrollPosition, 0.0f, CfgFlag::DEFAULT),
245
	ConfigSetting("DebugOverlay", &g_Config.iDebugOverlay, 0, CfgFlag::DONT_SAVE),
246
	ConfigSetting("DefaultTab", &g_Config.iDefaultTab, 0, CfgFlag::DEFAULT),
247
	ConfigSetting("DisableHLEFlags", &g_Config.iDisableHLE, 0, CfgFlag::PER_GAME),
248
	ConfigSetting("ForceEnableHLEFlags", &g_Config.iForceEnableHLE, 0, CfgFlag::PER_GAME),
249

250
	ConfigSetting("ScreenshotMode", &g_Config.iScreenshotMode, 0, CfgFlag::DEFAULT),
251
	ConfigSetting("ScreenshotsAsPNG", &g_Config.bScreenshotsAsPNG, false, CfgFlag::PER_GAME),
252
	ConfigSetting("UseFFV1", &g_Config.bUseFFV1, false, CfgFlag::DEFAULT),
253
	ConfigSetting("DumpFrames", &g_Config.bDumpFrames, false, CfgFlag::DEFAULT),
254
	ConfigSetting("DumpVideoOutput", &g_Config.bDumpVideoOutput, false, CfgFlag::DEFAULT),
255
	ConfigSetting("DumpAudio", &g_Config.bDumpAudio, false, CfgFlag::DEFAULT),
256
	ConfigSetting("SaveLoadResetsAVdumping", &g_Config.bSaveLoadResetsAVdumping, false, CfgFlag::DEFAULT),
257
	ConfigSetting("StateSlot", &g_Config.iCurrentStateSlot, 0, CfgFlag::PER_GAME),
258
	ConfigSetting("EnableStateUndo", &g_Config.bEnableStateUndo, &DefaultEnableStateUndo, CfgFlag::PER_GAME),
259
	ConfigSetting("StateLoadUndoGame", &g_Config.sStateLoadUndoGame, "NA", CfgFlag::DEFAULT),
260
	ConfigSetting("StateUndoLastSaveGame", &g_Config.sStateUndoLastSaveGame, "NA", CfgFlag::DEFAULT),
261
	ConfigSetting("StateUndoLastSaveSlot", &g_Config.iStateUndoLastSaveSlot, -5, CfgFlag::DEFAULT), // Start with an "invalid" value
262
	ConfigSetting("RewindSnapshotInterval", &g_Config.iRewindSnapshotInterval, 0, CfgFlag::PER_GAME),
263

264
	ConfigSetting("ShowRegionOnGameIcon", &g_Config.bShowRegionOnGameIcon, false, CfgFlag::DEFAULT),
265
	ConfigSetting("ShowIDOnGameIcon", &g_Config.bShowIDOnGameIcon, false, CfgFlag::DEFAULT),
266
	ConfigSetting("GameGridScale", &g_Config.fGameGridScale, 1.0, CfgFlag::DEFAULT),
267
	ConfigSetting("GridView1", &g_Config.bGridView1, true, CfgFlag::DEFAULT),
268
	ConfigSetting("GridView2", &g_Config.bGridView2, true, CfgFlag::DEFAULT),
269
	ConfigSetting("GridView3", &g_Config.bGridView3, false, CfgFlag::DEFAULT),
270
	ConfigSetting("RightAnalogUp", &g_Config.iRightAnalogUp, 0, CfgFlag::PER_GAME),
271
	ConfigSetting("RightAnalogDown", &g_Config.iRightAnalogDown, 0, CfgFlag::PER_GAME),
272
	ConfigSetting("RightAnalogLeft", &g_Config.iRightAnalogLeft, 0, CfgFlag::PER_GAME),
273
	ConfigSetting("RightAnalogRight", &g_Config.iRightAnalogRight, 0, CfgFlag::PER_GAME),
274
	ConfigSetting("RightAnalogPress", &g_Config.iRightAnalogPress, 0, CfgFlag::PER_GAME),
275
	ConfigSetting("RightAnalogCustom", &g_Config.bRightAnalogCustom, false, CfgFlag::PER_GAME),
276
	ConfigSetting("RightAnalogDisableDiagonal", &g_Config.bRightAnalogDisableDiagonal, false, CfgFlag::PER_GAME),
277
	ConfigSetting("SwipeUp", &g_Config.iSwipeUp, 0, CfgFlag::PER_GAME),
278
	ConfigSetting("SwipeDown", &g_Config.iSwipeDown, 0, CfgFlag::PER_GAME),
279
	ConfigSetting("SwipeLeft", &g_Config.iSwipeLeft, 0, CfgFlag::PER_GAME),
280
	ConfigSetting("SwipeRight", &g_Config.iSwipeRight, 0, CfgFlag::PER_GAME),
281
	ConfigSetting("SwipeSensitivity", &g_Config.fSwipeSensitivity, 1.0f, CfgFlag::PER_GAME),
282
	ConfigSetting("SwipeSmoothing", &g_Config.fSwipeSmoothing, 0.3f, CfgFlag::PER_GAME),
283
	ConfigSetting("DoubleTapGesture", &g_Config.iDoubleTapGesture, 0, CfgFlag::PER_GAME),
284
	ConfigSetting("GestureControlEnabled", &g_Config.bGestureControlEnabled, false, CfgFlag::PER_GAME),
285
	ConfigSetting("TouchGliding", &g_Config.bTouchGliding, false, CfgFlag::PER_GAME),
286

287
	// "default" means let emulator decide, "" means disable.
288
	ConfigSetting("ReportingHost", &g_Config.sReportHost, "default", CfgFlag::DEFAULT),
289
	ConfigSetting("AutoSaveSymbolMap", &g_Config.bAutoSaveSymbolMap, false, CfgFlag::PER_GAME),
290
	ConfigSetting("CompressSymbols", &g_Config.bCompressSymbols, true, CfgFlag::DEFAULT),
291
	ConfigSetting("CacheFullIsoInRam", &g_Config.bCacheFullIsoInRam, false, CfgFlag::PER_GAME),
292
	ConfigSetting("RemoteISOPort", &g_Config.iRemoteISOPort, 0, CfgFlag::DEFAULT),
293
	ConfigSetting("LastRemoteISOServer", &g_Config.sLastRemoteISOServer, "", CfgFlag::DEFAULT),
294
	ConfigSetting("LastRemoteISOPort", &g_Config.iLastRemoteISOPort, 0, CfgFlag::DEFAULT),
295
	ConfigSetting("RemoteISOManualConfig", &g_Config.bRemoteISOManual, false, CfgFlag::DEFAULT),
296
	ConfigSetting("RemoteShareOnStartup", &g_Config.bRemoteShareOnStartup, false, CfgFlag::DEFAULT),
297
	ConfigSetting("RemoteISOSubdir", &g_Config.sRemoteISOSubdir, "/", CfgFlag::DEFAULT),
298
	ConfigSetting("RemoteDebuggerOnStartup", &g_Config.bRemoteDebuggerOnStartup, false, CfgFlag::DEFAULT),
299
	ConfigSetting("RemoteTab", &g_Config.bRemoteTab, false, CfgFlag::DEFAULT),
300
	ConfigSetting("RemoteISOSharedDir", &g_Config.sRemoteISOSharedDir, "", CfgFlag::DEFAULT),
301
	ConfigSetting("RemoteISOShareType", &g_Config.iRemoteISOShareType, (int)RemoteISOShareType::RECENT, CfgFlag::DEFAULT),
302
	ConfigSetting("AskForExitConfirmationAfterSeconds", &g_Config.iAskForExitConfirmationAfterSeconds, 60, CfgFlag::PER_GAME),
303

304
#ifdef __ANDROID__
305
	ConfigSetting("ScreenRotation", &g_Config.iScreenRotation, ROTATION_AUTO_HORIZONTAL),
306
#endif
307
	ConfigSetting("InternalScreenRotation", &g_Config.iInternalScreenRotation, ROTATION_LOCKED_HORIZONTAL, CfgFlag::PER_GAME),
308

309
	ConfigSetting("BackgroundAnimation", &g_Config.iBackgroundAnimation, 1, CfgFlag::DEFAULT),
310
	ConfigSetting("TransparentBackground", &g_Config.bTransparentBackground, true, CfgFlag::DEFAULT),
311
	ConfigSetting("UITint", &g_Config.fUITint, 0.0, CfgFlag::DEFAULT),
312
	ConfigSetting("UISaturation", &g_Config.fUISaturation, &DefaultUISaturation, CfgFlag::DEFAULT),
313

314
#if defined(USING_WIN_UI)
315
	ConfigSetting("TopMost", &g_Config.bTopMost, false, CfgFlag::DEFAULT),
316
	ConfigSetting("PauseOnLostFocus", &g_Config.bPauseOnLostFocus, false, CfgFlag::PER_GAME),
317
#endif
318

319
#if !defined(MOBILE_DEVICE)
320
	ConfigSetting("WindowX", &g_Config.iWindowX, -1, CfgFlag::DEFAULT), // -1 tells us to center the window.
321
	ConfigSetting("WindowY", &g_Config.iWindowY, -1, CfgFlag::DEFAULT),
322
	ConfigSetting("WindowWidth", &g_Config.iWindowWidth, 0, CfgFlag::DEFAULT),   // 0 will be automatically reset later (need to do the AdjustWindowRect dance).
323
	ConfigSetting("WindowHeight", &g_Config.iWindowHeight, 0, CfgFlag::DEFAULT),
324
#endif
325

326
	ConfigSetting("PauseWhenMinimized", &g_Config.bPauseWhenMinimized, false, CfgFlag::PER_GAME),
327
	ConfigSetting("PauseExitsEmulator", &g_Config.bPauseExitsEmulator, false, CfgFlag::DONT_SAVE),
328
	ConfigSetting("PauseMenuExitsEmulator", &g_Config.bPauseMenuExitsEmulator, false, CfgFlag::DONT_SAVE),
329

330
	ConfigSetting("DumpFileTypes", &g_Config.iDumpFileTypes, 0, CfgFlag::PER_GAME),
331

332
	ConfigSetting("FullscreenOnDoubleclick", &g_Config.bFullscreenOnDoubleclick, true, CfgFlag::DONT_SAVE),
333
	ConfigSetting("ShowMenuBar", &g_Config.bShowMenuBar, true, CfgFlag::DEFAULT),
334

335
	ConfigSetting("MemStickInserted", &g_Config.bMemStickInserted, true, CfgFlag::PER_GAME | CfgFlag::REPORT),
336
	ConfigSetting("LoadPlugins", &g_Config.bLoadPlugins, true, CfgFlag::PER_GAME),
337
	ConfigSetting("NotificationPos", &g_Config.iNotificationPos, (int)ScreenEdgePosition::TOP_CENTER, CfgFlag::DEFAULT),
338

339
	ConfigSetting("IgnoreCompatSettings", &g_Config.sIgnoreCompatSettings, "", CfgFlag::PER_GAME | CfgFlag::REPORT),
340

341
	ConfigSetting("RunBehindPauseMenu", &g_Config.bRunBehindPauseMenu, false, CfgFlag::DEFAULT),
342

343
	ConfigSetting("ShowGPOLEDs", &g_Config.bShowGPOLEDs, false, CfgFlag::PER_GAME),
344

345
	ConfigSetting("UIScaleFactor", &g_Config.iUIScaleFactor, &DefaultUIScaleFactor, CfgFlag::DEFAULT),
346

347
	ConfigSetting("VulkanDisableImplicitLayers", &g_Config.bVulkanDisableImplicitLayers, false, CfgFlag::DEFAULT),
348
};
349

350
static bool DefaultSasThread() {
351
	return cpu_info.num_cores > 1;
352
}
353

354
static const ConfigSetting achievementSettings[] = {
355
	// Core settings
356
	ConfigSetting("AchievementsEnable", &g_Config.bAchievementsEnable, false, CfgFlag::DEFAULT),
357
	ConfigSetting("AchievementsEnableRAIntegration", &g_Config.bAchievementsEnableRAIntegration, false, CfgFlag::DEFAULT),
358
	ConfigSetting("AchievementsChallengeMode", &g_Config.bAchievementsHardcoreMode, true, CfgFlag::PER_GAME | CfgFlag::DEFAULT),
359
	ConfigSetting("AchievementsEncoreMode", &g_Config.bAchievementsEncoreMode, false, CfgFlag::PER_GAME | CfgFlag::DEFAULT),
360
	ConfigSetting("AchievementsUnofficial", &g_Config.bAchievementsUnofficial, false, CfgFlag::PER_GAME | CfgFlag::DEFAULT),
361
	ConfigSetting("AchievementsLogBadMemReads", &g_Config.bAchievementsLogBadMemReads, false, CfgFlag::DEFAULT),
362
	ConfigSetting("AchievementsSaveStateInHardcoreMode", &g_Config.bAchievementsSaveStateInHardcoreMode, false, CfgFlag::DEFAULT),
363

364
	// Achievements login info. Note that password is NOT stored, only a login token.
365
	// And that login token is stored separately from the ini, see NativeSaveSecret, but it can also be loaded
366
	// from the ini if manually entered (useful when testing various builds on Android).
367
	ConfigSetting("AchievementsToken", &g_Config.sAchievementsToken, "", CfgFlag::DONT_SAVE),
368
	ConfigSetting("AchievementsUserName", &g_Config.sAchievementsUserName, "", CfgFlag::DEFAULT),
369

370
	// Customizations
371
	ConfigSetting("AchievementsSoundEffects", &g_Config.bAchievementsSoundEffects, true, CfgFlag::DEFAULT),
372
	ConfigSetting("AchievementsUnlockAudioFile", &g_Config.sAchievementsUnlockAudioFile, "", CfgFlag::DEFAULT),
373
	ConfigSetting("AchievementsLeaderboardSubmitAudioFile", &g_Config.sAchievementsLeaderboardSubmitAudioFile, "", CfgFlag::DEFAULT),
374

375
	ConfigSetting("AchievementsLeaderboardTrackerPos", &g_Config.iAchievementsLeaderboardTrackerPos, (int)ScreenEdgePosition::TOP_LEFT, CfgFlag::PER_GAME | CfgFlag::DEFAULT),
376
	ConfigSetting("AchievementsLeaderboardStartedOrFailedPos", &g_Config.iAchievementsLeaderboardStartedOrFailedPos, (int)ScreenEdgePosition::TOP_LEFT, CfgFlag::PER_GAME | CfgFlag::DEFAULT),
377
	ConfigSetting("AchievementsLeaderboardSubmittedPos", &g_Config.iAchievementsLeaderboardSubmittedPos, (int)ScreenEdgePosition::TOP_LEFT, CfgFlag::PER_GAME | CfgFlag::DEFAULT),
378
	ConfigSetting("AchievementsProgressPos", &g_Config.iAchievementsProgressPos, (int)ScreenEdgePosition::TOP_LEFT, CfgFlag::PER_GAME | CfgFlag::DEFAULT),
379
	ConfigSetting("AchievementsChallengePos", &g_Config.iAchievementsChallengePos, (int)ScreenEdgePosition::TOP_LEFT, CfgFlag::PER_GAME | CfgFlag::DEFAULT),
380
	ConfigSetting("AchievementsUnlockedPos", &g_Config.iAchievementsUnlockedPos, (int)ScreenEdgePosition::TOP_CENTER, CfgFlag::PER_GAME | CfgFlag::DEFAULT),
381
};
382

383
static const ConfigSetting cpuSettings[] = {
384
	ConfigSetting("CPUCore", &g_Config.iCpuCore, &DefaultCpuCore, CfgFlag::PER_GAME | CfgFlag::REPORT),
385
	ConfigSetting("SeparateSASThread", &g_Config.bSeparateSASThread, &DefaultSasThread, CfgFlag::PER_GAME | CfgFlag::REPORT),
386
	ConfigSetting("IOTimingMethod", &g_Config.iIOTimingMethod, IOTIMING_FAST, CfgFlag::PER_GAME | CfgFlag::REPORT),
387
	ConfigSetting("FastMemoryAccess", &g_Config.bFastMemory, true, CfgFlag::PER_GAME),
388
	ConfigSetting("FunctionReplacements", &g_Config.bFuncReplacements, true, CfgFlag::PER_GAME | CfgFlag::REPORT),
389
	ConfigSetting("HideSlowWarnings", &g_Config.bHideSlowWarnings, false, CfgFlag::DEFAULT),
390
	ConfigSetting("HideStateWarnings", &g_Config.bHideStateWarnings, false, CfgFlag::DEFAULT),
391
	ConfigSetting("JitDisableFlags", &g_Config.uJitDisableFlags, (uint32_t)0, CfgFlag::PER_GAME),
392
	ConfigSetting("CPUSpeed", &g_Config.iLockedCPUSpeed, 0, CfgFlag::PER_GAME | CfgFlag::REPORT),
393
};
394

395
static int DefaultInternalResolution() {
396
	// Auto on Windows and Linux, 2x on large screens and iOS, 1x elsewhere.
397
#if defined(USING_WIN_UI) || defined(USING_QT_UI)
398
	return 0;
399
#elif PPSSPP_PLATFORM(IOS)
400
	return 2;
401
#else
402
	if (System_GetPropertyInt(SYSPROP_DEVICE_TYPE) == DEVICE_TYPE_VR) {
403
		return 4;
404
	}
405
	int longestDisplaySide = std::max(System_GetPropertyInt(SYSPROP_DISPLAY_XRES), System_GetPropertyInt(SYSPROP_DISPLAY_YRES));
406
	int scale = longestDisplaySide >= 1000 ? 2 : 1;
407
	INFO_LOG(Log::G3D, "Longest display side: %d pixels. Choosing scale %d", longestDisplaySide, scale);
408
	return scale;
409
#endif
410
}
411

412
static int DefaultFastForwardMode() {
413
#if PPSSPP_PLATFORM(ANDROID) || defined(USING_QT_UI) || PPSSPP_PLATFORM(UWP) || PPSSPP_PLATFORM(IOS)
414
	return (int)FastForwardMode::SKIP_FLIP;
415
#else
416
	return (int)FastForwardMode::CONTINUOUS;
417
#endif
418
}
419

420
static int DefaultAndroidHwScale() {
421
#if PPSSPP_PLATFORM(ANDROID)
422
	if (System_GetPropertyInt(SYSPROP_SYSTEMVERSION) >= 19 || System_GetPropertyInt(SYSPROP_DEVICE_TYPE) == DEVICE_TYPE_TV) {
423
		// Arbitrary cutoff at Kitkat - modern devices are usually powerful enough that hw scaling
424
		// doesn't really help very much and mostly causes problems. See #11151
425
		return 0;
426
	}
427

428
	// Get the real resolution as passed in during startup, not dp_xres and stuff
429
	int xres = System_GetPropertyInt(SYSPROP_DISPLAY_XRES);
430
	int yres = System_GetPropertyInt(SYSPROP_DISPLAY_YRES);
431

432
	if (xres <= 960) {
433
		// Smaller than the PSP*2, let's go native.
434
		return 0;
435
	} else if (xres <= 480 * 3) {  // 720p xres
436
		// Small-ish screen, we should default to 2x
437
		return 2 + 1;
438
	} else {
439
		// Large or very large screen. Default to 3x psp resolution.
440
		return 3 + 1;
441
	}
442
	return 0;
443
#else
444
	return 1;
445
#endif
446
}
447

448
// See issue 14439. Should possibly even block these devices from selecting VK.
449
const char * const vulkanDefaultBlacklist[] = {
450
	"Sony:BRAVIA VH1",
451
};
452

453
static int DefaultGPUBackend() {
454
	if (IsVREnabled()) {
455
		return (int)GPUBackend::OPENGL;
456
	}
457

458
#if PPSSPP_PLATFORM(WINDOWS)
459
	// On Win10, there's a good chance Vulkan will work by default.
460
	if (IsWin10OrHigher()) {
461
		return (int)GPUBackend::VULKAN;
462
	}
463
	// On older Windows, to be safe, use Direct3D 11.
464
	if (IsWin8OrHigher()) {
465
		return (int)GPUBackend::DIRECT3D11;
466
	}
467
#elif PPSSPP_PLATFORM(ANDROID)
468
	// Check blacklist.
469
	for (size_t i = 0; i < ARRAY_SIZE(vulkanDefaultBlacklist); i++) {
470
		if (System_GetProperty(SYSPROP_NAME) == vulkanDefaultBlacklist[i]) {
471
			return (int)GPUBackend::OPENGL;
472
		}
473
	}
474

475
	// Default to Vulkan only on Oreo 8.1 (level 27) devices or newer, and only
476
	// on ARM64 and x86-64. Drivers before, and on other archs, are generally too
477
	// unreliable to default to (with some exceptions, of course).
478
#if PPSSPP_ARCH(64BIT)
479
	if (System_GetPropertyInt(SYSPROP_SYSTEMVERSION) >= 27) {
480
		return (int)GPUBackend::VULKAN;
481
	}
482
#else
483
	// There are some newer devices that benefit from Vulkan as default, but are 32-bit. Example: Redmi 9A.
484
	// Let's only allow the very newest generation though.
485
	if (System_GetPropertyInt(SYSPROP_SYSTEMVERSION) >= 30) {
486
		return (int)GPUBackend::VULKAN;
487
	}
488
#endif
489

490
#elif PPSSPP_PLATFORM(MAC)
491

492
#if PPSSPP_ARCH(ARM64)
493
	return (int)GPUBackend::VULKAN;
494
#else
495
	// On Intel (generally older Macs) default to OpenGL.
496
	return (int)GPUBackend::OPENGL;
497
#endif
498

499
#elif PPSSPP_PLATFORM(IOS_APP_STORE)
500
	return (int)GPUBackend::VULKAN;
501
#endif
502

503
	// TODO: On some additional Linux platforms, we should also default to Vulkan.
504
	return (int)GPUBackend::OPENGL;
505
}
506

507
int Config::NextValidBackend() {
508
	std::vector<std::string> split;
509
	std::set<GPUBackend> failed;
510

511
	SplitString(sFailedGPUBackends, ',', split);
512
	for (const auto &str : split) {
513
		if (!str.empty() && str != "ALL") {
514
			failed.insert(GPUBackendFromString(str));
515
		}
516
	}
517

518
	// Count these as "failed" too so we don't pick them.
519
	SplitString(sDisabledGPUBackends, ',', split);
520
	for (const auto &str : split) {
521
		if (!str.empty()) {
522
			failed.insert(GPUBackendFromString(str));
523
		}
524
	}
525

526
	if (failed.count((GPUBackend)iGPUBackend)) {
527
		ERROR_LOG(Log::Loader, "Graphics backend failed for %d, trying another", iGPUBackend);
528

529
#if !PPSSPP_PLATFORM(UWP)
530
		if (!failed.count(GPUBackend::VULKAN) && VulkanMayBeAvailable()) {
531
			return (int)GPUBackend::VULKAN;
532
		}
533
#endif
534
#if PPSSPP_PLATFORM(WINDOWS)
535
		if (!failed.count(GPUBackend::DIRECT3D11) && IsWin7OrHigher()) {
536
			return (int)GPUBackend::DIRECT3D11;
537
		}
538
#endif
539
#if PPSSPP_API(ANY_GL)
540
		if (!failed.count(GPUBackend::OPENGL)) {
541
			return (int)GPUBackend::OPENGL;
542
		}
543
#endif
544

545
		// They've all failed.  Let them try the default - or on Android, OpenGL.
546
		sFailedGPUBackends += ",ALL";
547
		ERROR_LOG(Log::Loader, "All graphics backends failed");
548
#if PPSSPP_PLATFORM(ANDROID)
549
		return (int)GPUBackend::OPENGL;
550
#else
551
		return DefaultGPUBackend();
552
#endif
553
	}
554

555
	return iGPUBackend;
556
}
557

558
bool Config::IsBackendEnabled(GPUBackend backend) {
559
	std::vector<std::string> split;
560

561
	SplitString(sDisabledGPUBackends, ',', split);
562
	for (const auto &str : split) {
563
		if (str.empty())
564
			continue;
565
		auto match = GPUBackendFromString(str);
566
		if (match == backend)
567
			return false;
568
	}
569

570
#if PPSSPP_PLATFORM(UWP)
571
	if (backend != GPUBackend::DIRECT3D11)
572
		return false;
573
#elif PPSSPP_PLATFORM(SWITCH)
574
	if (backend != GPUBackend::OPENGL)
575
		return false;
576
#elif PPSSPP_PLATFORM(WINDOWS)
577
	if (backend == GPUBackend::DIRECT3D11 && !IsVistaOrHigher())
578
		return false;
579
#else
580
	if (backend == GPUBackend::DIRECT3D11)
581
		return false;
582
#endif
583

584
#if !PPSSPP_API(ANY_GL)
585
	if (backend == GPUBackend::OPENGL)
586
		return false;
587
#endif
588
	if (backend == GPUBackend::VULKAN && !VulkanMayBeAvailable())
589
		return false;
590
	return true;
591
}
592

593
template <typename T, std::string (*FTo)(T), T (*FFrom)(std::string_view)>
594
struct ConfigTranslator {
595
	static std::string To(int v) {
596
		return StringFromInt(v) + " (" + FTo(T(v)) + ")";
597
	}
598

599
	static int From(const std::string &v) {
600
		int result;
601
		if (TryParse(v, &result)) {
602
			return result;
603
		}
604
		return (int)FFrom(v);
605
	}
606
};
607

608
typedef ConfigTranslator<GPUBackend, GPUBackendToString, GPUBackendFromString> GPUBackendTranslator;
609

610
static int FastForwardModeFromString(const std::string &s) {
611
	if (!strcasecmp(s.c_str(), "CONTINUOUS"))
612
		return (int)FastForwardMode::CONTINUOUS;
613
	if (!strcasecmp(s.c_str(), "SKIP_FLIP"))
614
		return (int)FastForwardMode::SKIP_FLIP;
615
	return DefaultFastForwardMode();
616
}
617

618
static std::string FastForwardModeToString(int v) {
619
	switch (FastForwardMode(v)) {
620
	case FastForwardMode::CONTINUOUS:
621
		return "CONTINUOUS";
622
	case FastForwardMode::SKIP_FLIP:
623
		return "SKIP_FLIP";
624
	}
625
	return "CONTINUOUS";
626
}
627

628
static std::string DefaultInfrastructureUsername() {
629
	// If the user has already picked a Nickname that satisfies the rules and is not "PPSSPP",
630
	// let's use that.
631
	// NOTE: This type of dependency means that network settings must be AFTER system settings in sections[].
632
	if (g_Config.sNickName != "PPSSPP" &&
633
		!g_Config.sNickName.empty() &&
634
		g_Config.sNickName == SanitizeString(g_Config.sNickName, StringRestriction::AlphaNumDashUnderscore, 3, 16)) {
635
		return g_Config.sNickName;
636
	}
637

638
	// Otherwise let's leave it empty, which will result in login failure and a warning.
639
	return std::string();
640
}
641

642
static const ConfigSetting graphicsSettings[] = {
643
	ConfigSetting("EnableCardboardVR", &g_Config.bEnableCardboardVR, false, CfgFlag::PER_GAME),
644
	ConfigSetting("CardboardScreenSize", &g_Config.iCardboardScreenSize, 50, CfgFlag::PER_GAME),
645
	ConfigSetting("CardboardXShift", &g_Config.iCardboardXShift, 0, CfgFlag::PER_GAME),
646
	ConfigSetting("CardboardYShift", &g_Config.iCardboardYShift, 0, CfgFlag::PER_GAME),
647
	ConfigSetting("iShowStatusFlags", &g_Config.iShowStatusFlags, 0, CfgFlag::PER_GAME),
648
	ConfigSetting("GraphicsBackend", &g_Config.iGPUBackend, &DefaultGPUBackend, &GPUBackendTranslator::To, &GPUBackendTranslator::From, CfgFlag::DEFAULT | CfgFlag::REPORT),
649
#if PPSSPP_PLATFORM(ANDROID) && PPSSPP_ARCH(ARM64)
650
	ConfigSetting("CustomDriver", &g_Config.sCustomDriver, "", CfgFlag::DEFAULT),
651
#endif
652
	ConfigSetting("DisabledGraphicsBackends", &g_Config.sDisabledGPUBackends, "", CfgFlag::DEFAULT),
653
	ConfigSetting("VulkanDevice", &g_Config.sVulkanDevice, "", CfgFlag::DEFAULT),
654
#ifdef _WIN32
655
	ConfigSetting("D3D11Device", &g_Config.sD3D11Device, "", CfgFlag::DEFAULT),
656
#endif
657
	ConfigSetting("CameraDevice", &g_Config.sCameraDevice, "", CfgFlag::DEFAULT),
658
	ConfigSetting("CameraMirrorHorizontal", &g_Config.bCameraMirrorHorizontal, false, CfgFlag::DEFAULT),
659
	ConfigSetting("AndroidFramerateMode", &g_Config.iDisplayFramerateMode, 1, CfgFlag::DEFAULT),
660
	ConfigSetting("VendorBugChecksEnabled", &g_Config.bVendorBugChecksEnabled, true, CfgFlag::DONT_SAVE),
661
	ConfigSetting("UseGeometryShader", &g_Config.bUseGeometryShader, false, CfgFlag::PER_GAME),
662
	ConfigSetting("SkipBufferEffects", &g_Config.bSkipBufferEffects, false, CfgFlag::PER_GAME | CfgFlag::REPORT),
663
	ConfigSetting("DisableRangeCulling", &g_Config.bDisableRangeCulling, false, CfgFlag::PER_GAME | CfgFlag::REPORT),
664
	ConfigSetting("DepthRasterMode", &g_Config.iDepthRasterMode, &DefaultDepthRaster, CfgFlag::PER_GAME | CfgFlag::REPORT),
665
	ConfigSetting("SoftwareRenderer", &g_Config.bSoftwareRendering, false, CfgFlag::PER_GAME),
666
	ConfigSetting("SoftwareRendererJit", &g_Config.bSoftwareRenderingJit, true, CfgFlag::PER_GAME),
667
	ConfigSetting("HardwareTransform", &g_Config.bHardwareTransform, true, CfgFlag::PER_GAME | CfgFlag::REPORT),
668
	ConfigSetting("SoftwareSkinning", &g_Config.bSoftwareSkinning, true, CfgFlag::PER_GAME | CfgFlag::REPORT),
669
	ConfigSetting("TextureFiltering", &g_Config.iTexFiltering, 1, CfgFlag::PER_GAME | CfgFlag::REPORT),
670
	ConfigSetting("Smart2DTexFiltering", &g_Config.bSmart2DTexFiltering, false, CfgFlag::PER_GAME | CfgFlag::REPORT),
671
	ConfigSetting("InternalResolution", &g_Config.iInternalResolution, &DefaultInternalResolution, CfgFlag::PER_GAME | CfgFlag::REPORT),
672
	ConfigSetting("AndroidHwScale", &g_Config.iAndroidHwScale, &DefaultAndroidHwScale, CfgFlag::DEFAULT),
673
	ConfigSetting("HighQualityDepth", &g_Config.bHighQualityDepth, true, CfgFlag::PER_GAME | CfgFlag::REPORT),
674
	ConfigSetting("FrameSkip", &g_Config.iFrameSkip, 0, CfgFlag::PER_GAME | CfgFlag::REPORT),
675
	ConfigSetting("FrameSkipType", &g_Config.iFrameSkipType, 0, CfgFlag::PER_GAME | CfgFlag::REPORT),
676
	ConfigSetting("AutoFrameSkip", &g_Config.bAutoFrameSkip, IsVREnabled(), CfgFlag::PER_GAME | CfgFlag::REPORT),
677
	ConfigSetting("StereoRendering", &g_Config.bStereoRendering, false, CfgFlag::PER_GAME),
678
	ConfigSetting("StereoToMonoShader", &g_Config.sStereoToMonoShader, "RedBlue", CfgFlag::PER_GAME),
679
	ConfigSetting("FrameRate", &g_Config.iFpsLimit1, 0, CfgFlag::PER_GAME),
680
	ConfigSetting("FrameRate2", &g_Config.iFpsLimit2, -1, CfgFlag::PER_GAME),
681
	ConfigSetting("AnalogFrameRate", &g_Config.iAnalogFpsLimit, 240, CfgFlag::PER_GAME),
682
	ConfigSetting("UnthrottlingMode", &g_Config.iFastForwardMode, &DefaultFastForwardMode, &FastForwardModeToString, &FastForwardModeFromString, CfgFlag::PER_GAME),
683
#if defined(USING_WIN_UI)
684
	ConfigSetting("RestartRequired", &g_Config.bRestartRequired, false, CfgFlag::DONT_SAVE),
685
#endif
686

687
	// Most low-performance (and many high performance) mobile GPUs do not support aniso anyway so defaulting to 4 is fine.
688
	ConfigSetting("AnisotropyLevel", &g_Config.iAnisotropyLevel, 4, CfgFlag::PER_GAME),
689
	ConfigSetting("MultiSampleLevel", &g_Config.iMultiSampleLevel, 0, CfgFlag::PER_GAME),  // Number of samples is 1 << iMultiSampleLevel
690

691
	ConfigSetting("TextureBackoffCache", &g_Config.bTextureBackoffCache, false, CfgFlag::PER_GAME | CfgFlag::REPORT),
692
	ConfigSetting("VertexDecJit", &g_Config.bVertexDecoderJit, &DefaultCodeGen, CfgFlag::DONT_SAVE | CfgFlag::REPORT),
693

694
#ifndef MOBILE_DEVICE
695
	ConfigSetting("FullScreen", &g_Config.bFullScreen, false, CfgFlag::DEFAULT),
696
	ConfigSetting("FullScreenMulti", &g_Config.bFullScreenMulti, false, CfgFlag::DEFAULT),
697
#endif
698

699
#if PPSSPP_PLATFORM(IOS)
700
	ConfigSetting("AppSwitchMode", &g_Config.iAppSwitchMode, (int)AppSwitchMode::DOUBLE_SWIPE_INDICATOR, CfgFlag::DEFAULT),
701
#endif
702

703
	ConfigSetting("BufferFiltering", &g_Config.iDisplayFilter, SCALE_LINEAR, CfgFlag::PER_GAME),
704
	ConfigSetting("DisplayOffsetX", &g_Config.fDisplayOffsetX, 0.5f, CfgFlag::PER_GAME),
705
	ConfigSetting("DisplayOffsetY", &g_Config.fDisplayOffsetY, 0.5f, CfgFlag::PER_GAME),
706
	ConfigSetting("DisplayScale", &g_Config.fDisplayScale, 1.0f, CfgFlag::PER_GAME),
707
	ConfigSetting("DisplayIntegerScale", &g_Config.bDisplayIntegerScale, false, CfgFlag::PER_GAME),
708
	ConfigSetting("DisplayAspectRatio", &g_Config.fDisplayAspectRatio, 1.0f, CfgFlag::PER_GAME),
709
	ConfigSetting("DisplayStretch", &g_Config.bDisplayStretch, false, CfgFlag::PER_GAME),
710
	ConfigSetting("DisplayCropTo16x9", &g_Config.bDisplayCropTo16x9, true, CfgFlag::PER_GAME),
711

712
	ConfigSetting("ImmersiveMode", &g_Config.bImmersiveMode, true, CfgFlag::PER_GAME),
713
	ConfigSetting("SustainedPerformanceMode", &g_Config.bSustainedPerformanceMode, false, CfgFlag::PER_GAME),
714
	ConfigSetting("IgnoreScreenInsets", &g_Config.bIgnoreScreenInsets, true, CfgFlag::DEFAULT),
715

716
	ConfigSetting("ReplaceTextures", &g_Config.bReplaceTextures, true, CfgFlag::PER_GAME | CfgFlag::REPORT),
717
	ConfigSetting("SaveNewTextures", &g_Config.bSaveNewTextures, false, CfgFlag::PER_GAME | CfgFlag::REPORT),
718
	ConfigSetting("IgnoreTextureFilenames", &g_Config.bIgnoreTextureFilenames, false, CfgFlag::PER_GAME),
719
	ConfigSetting("ReplacementTextureLoadSpeed", &g_Config.iReplacementTextureLoadSpeed, 0, CfgFlag::PER_GAME),
720

721
	ConfigSetting("TexScalingLevel", &g_Config.iTexScalingLevel, 1, CfgFlag::PER_GAME | CfgFlag::REPORT),
722
	ConfigSetting("TexScalingType", &g_Config.iTexScalingType, 0, CfgFlag::PER_GAME | CfgFlag::REPORT),
723
	ConfigSetting("TexDeposterize", &g_Config.bTexDeposterize, false, CfgFlag::PER_GAME | CfgFlag::REPORT),
724
	ConfigSetting("TexHardwareScaling", &g_Config.bTexHardwareScaling, false, CfgFlag::PER_GAME | CfgFlag::REPORT),
725
	ConfigSetting("VSync", &g_Config.bVSync, &DefaultVSync, CfgFlag::PER_GAME),
726
	ConfigSetting("BloomHack", &g_Config.iBloomHack, 0, CfgFlag::PER_GAME | CfgFlag::REPORT),
727

728
	// Not really a graphics setting...
729
	ConfigSetting("SplineBezierQuality", &g_Config.iSplineBezierQuality, 2, CfgFlag::PER_GAME | CfgFlag::REPORT),
730
	ConfigSetting("HardwareTessellation", &g_Config.bHardwareTessellation, false, CfgFlag::PER_GAME | CfgFlag::REPORT),
731
	ConfigSetting("TextureShader", &g_Config.sTextureShaderName, "Off", CfgFlag::PER_GAME),
732
	ConfigSetting("ShaderChainRequires60FPS", &g_Config.bShaderChainRequires60FPS, false, CfgFlag::PER_GAME),
733

734
	ConfigSetting("SkipGPUReadbackMode", &g_Config.iSkipGPUReadbackMode, false, CfgFlag::PER_GAME | CfgFlag::REPORT),
735

736
	ConfigSetting("GfxDebugOutput", &g_Config.bGfxDebugOutput, false, CfgFlag::DONT_SAVE),
737
	ConfigSetting("LogFrameDrops", &g_Config.bLogFrameDrops, false, CfgFlag::DEFAULT),
738

739
	ConfigSetting("InflightFrames", &g_Config.iInflightFrames, 3, CfgFlag::DEFAULT),
740
	ConfigSetting("RenderDuplicateFrames", &g_Config.bRenderDuplicateFrames, false, CfgFlag::PER_GAME),
741

742
	ConfigSetting("MultiThreading", &g_Config.bRenderMultiThreading, true, CfgFlag::DEFAULT),
743

744
	ConfigSetting("ShaderCache", &g_Config.bShaderCache, true, CfgFlag::DEFAULT),
745
	ConfigSetting("GpuLogProfiler", &g_Config.bGpuLogProfiler, false, CfgFlag::DEFAULT),
746

747
	ConfigSetting("UberShaderVertex", &g_Config.bUberShaderVertex, true, CfgFlag::DEFAULT),
748
	ConfigSetting("UberShaderFragment", &g_Config.bUberShaderFragment, true, CfgFlag::DEFAULT),
749

750
	ConfigSetting("DisplayRefreshRate", &g_Config.iDisplayRefreshRate, g_Config.iDisplayRefreshRate, CfgFlag::PER_GAME),
751
};
752

753
static int LegacyVolumeToNewVolume(int legacy, int max) {
754
	float multiplier = Volume10ToMultiplier(legacy);
755
	return std::clamp(MultiplierToVolume100(multiplier), 0, max);
756
}
757

758
static int DefaultGameVolume() {
759
	return LegacyVolumeToNewVolume(g_Config.iLegacyGameVolume, 100);
760
}
761

762
static int DefaultReverbVolume() {
763
	return LegacyVolumeToNewVolume(g_Config.iLegacyReverbVolume, 200);
764
}
765

766
static int DefaultAchievementVolume() {
767
	// NOTE: The old achievemnt volume was a straight percentage so it doesn't convert
768
	// the same as the others.
769
	return MultiplierToVolume100((float)g_Config.iLegacyAchievementVolume / 10.0f);
770
}
771

772
static int DefaultGamePreviewVolume() {
773
	// This was previously controlled by the UI volume, so transfer the default value over.
774
	return g_Config.iUIVolume;
775
}
776

777
static const ConfigSetting soundSettings[] = {
778
	ConfigSetting("Enable", &g_Config.bEnableSound, true, CfgFlag::PER_GAME),
779
	ConfigSetting("ExtraAudioBuffering", &g_Config.bExtraAudioBuffering, false, CfgFlag::DEFAULT),
780
	ConfigSetting("AudioBufferSize", &g_Config.iSDLAudioBufferSize, 256, CfgFlag::DEFAULT),
781

782
	// Legacy volume settings, these get auto upgraded through default handlers on the new settings. NOTE: Must be before the new ones in the order here.
783
	// The default settings here are still relevant, they will get propagated into the new ones.
784
	ConfigSetting("GlobalVolume", &g_Config.iLegacyGameVolume, VOLUME_FULL, CfgFlag::PER_GAME | CfgFlag::DONT_SAVE),
785
	ConfigSetting("ReverbVolume", &g_Config.iLegacyReverbVolume, VOLUME_FULL, CfgFlag::PER_GAME | CfgFlag::DONT_SAVE),
786
	ConfigSetting("AchievementSoundVolume", &g_Config.iLegacyAchievementVolume, 6, CfgFlag::PER_GAME | CfgFlag::DONT_SAVE),
787

788
	// Current volume settings.
789
	ConfigSetting("GameVolume", &g_Config.iGameVolume, &DefaultGameVolume, CfgFlag::PER_GAME),
790
	ConfigSetting("ReverbRelativeVolume", &g_Config.iReverbVolume, &DefaultReverbVolume, CfgFlag::PER_GAME),
791
	ConfigSetting("AltSpeedRelativeVolume", &g_Config.iAltSpeedVolume, VOLUMEHI_FULL, CfgFlag::PER_GAME),
792
	ConfigSetting("AchievementVolume", &g_Config.iAchievementVolume, &DefaultAchievementVolume, CfgFlag::PER_GAME),
793
	ConfigSetting("UIVolume", &g_Config.iUIVolume, 75, CfgFlag::DEFAULT),
794
	ConfigSetting("GamePreviewVolume", &g_Config.iGamePreviewVolume, &DefaultGamePreviewVolume, CfgFlag::DEFAULT),
795

796
	ConfigSetting("AudioDevice", &g_Config.sAudioDevice, "", CfgFlag::DEFAULT),
797
	ConfigSetting("AutoAudioDevice", &g_Config.bAutoAudioDevice, true, CfgFlag::DEFAULT),
798
	ConfigSetting("AudioMixWithOthers", &g_Config.bAudioMixWithOthers, true, CfgFlag::DEFAULT),
799
	ConfigSetting("AudioRespectSilentMode", &g_Config.bAudioRespectSilentMode, false, CfgFlag::DEFAULT),
800
	ConfigSetting("UseOldAtrac", &g_Config.bUseOldAtrac, false, CfgFlag::DEFAULT),
801
};
802

803
static bool DefaultShowTouchControls() {
804
	switch (System_GetPropertyInt(SYSPROP_DEVICE_TYPE)) {
805
	case DEVICE_TYPE_MOBILE:
806
		return !KeyMap::HasBuiltinController(System_GetProperty(SYSPROP_NAME));
807
	default:
808
		return false;
809
	}
810
}
811

812
static bool DefaultShowPauseButton() {
813
	switch (System_GetPropertyInt(SYSPROP_DEVICE_TYPE)) {
814
	case DEVICE_TYPE_MOBILE:
815
	case DEVICE_TYPE_DESKTOP:
816
		return true;
817
	case DEVICE_TYPE_VR:
818
	case DEVICE_TYPE_TV:
819
		return false;
820
	default:
821
		return false;
822
	}
823
}
824

825
static const float defaultControlScale = 1.15f;
826
static const ConfigTouchPos defaultTouchPosShow = { -1.0f, -1.0f, defaultControlScale, true };
827
static const ConfigTouchPos defaultTouchPosHide = { -1.0f, -1.0f, defaultControlScale, false };
828

829
static const ConfigSetting controlSettings[] = {
830
	ConfigSetting("HapticFeedback", &g_Config.bHapticFeedback, false, CfgFlag::PER_GAME),
831
	ConfigSetting("ShowTouchCross", &g_Config.bShowTouchCross, true, CfgFlag::PER_GAME),
832
	ConfigSetting("ShowTouchCircle", &g_Config.bShowTouchCircle, true, CfgFlag::PER_GAME),
833
	ConfigSetting("ShowTouchSquare", &g_Config.bShowTouchSquare, true, CfgFlag::PER_GAME),
834
	ConfigSetting("ShowTouchTriangle", &g_Config.bShowTouchTriangle, true, CfgFlag::PER_GAME),
835

836
	ConfigSetting("Custom0Mapping", "Custom0Image", "Custom0Shape", "Custom0Toggle", "Custom0Repeat", &g_Config.CustomButton[0], {0, 0, 0, false, false}, CfgFlag::PER_GAME),
837
	ConfigSetting("Custom1Mapping", "Custom1Image", "Custom1Shape", "Custom1Toggle", "Custom1Repeat", &g_Config.CustomButton[1], {0, 1, 0, false, false}, CfgFlag::PER_GAME),
838
	ConfigSetting("Custom2Mapping", "Custom2Image", "Custom2Shape", "Custom2Toggle", "Custom2Repeat", &g_Config.CustomButton[2], {0, 2, 0, false, false}, CfgFlag::PER_GAME),
839
	ConfigSetting("Custom3Mapping", "Custom3Image", "Custom3Shape", "Custom3Toggle", "Custom3Repeat", &g_Config.CustomButton[3], {0, 3, 0, false, false}, CfgFlag::PER_GAME),
840
	ConfigSetting("Custom4Mapping", "Custom4Image", "Custom4Shape", "Custom4Toggle", "Custom4Repeat", &g_Config.CustomButton[4], {0, 4, 0, false, false}, CfgFlag::PER_GAME),
841
	ConfigSetting("Custom5Mapping", "Custom5Image", "Custom5Shape", "Custom5Toggle", "Custom5Repeat", &g_Config.CustomButton[5], {0, 0, 1, false, false}, CfgFlag::PER_GAME),
842
	ConfigSetting("Custom6Mapping", "Custom6Image", "Custom6Shape", "Custom6Toggle", "Custom6Repeat", &g_Config.CustomButton[6], {0, 1, 1, false, false}, CfgFlag::PER_GAME),
843
	ConfigSetting("Custom7Mapping", "Custom7Image", "Custom7Shape", "Custom7Toggle", "Custom7Repeat", &g_Config.CustomButton[7], {0, 2, 1, false, false}, CfgFlag::PER_GAME),
844
	ConfigSetting("Custom8Mapping", "Custom8Image", "Custom8Shape", "Custom8Toggle", "Custom8Repeat", &g_Config.CustomButton[8], {0, 3, 1, false, false}, CfgFlag::PER_GAME),
845
	ConfigSetting("Custom9Mapping", "Custom9Image", "Custom9Shape", "Custom9Toggle", "Custom9Repeat", &g_Config.CustomButton[9], {0, 4, 1, false, false}, CfgFlag::PER_GAME),
846
	ConfigSetting("Custom10Mapping", "Custom10Image", "Custom10Shape", "Custom10Toggle", "Custom10Repeat", &g_Config.CustomButton[10], {0, 0, 2, false, false}, CfgFlag::PER_GAME),
847
	ConfigSetting("Custom11Mapping", "Custom11Image", "Custom11Shape", "Custom11Toggle", "Custom11Repeat", &g_Config.CustomButton[11], {0, 1, 2, false, false}, CfgFlag::PER_GAME),
848
	ConfigSetting("Custom12Mapping", "Custom12Image", "Custom12Shape", "Custom12Toggle", "Custom12Repeat", &g_Config.CustomButton[12], {0, 2, 2, false, false}, CfgFlag::PER_GAME),
849
	ConfigSetting("Custom13Mapping", "Custom13Image", "Custom13Shape", "Custom13Toggle", "Custom13Repeat", &g_Config.CustomButton[13], {0, 3, 2, false, false}, CfgFlag::PER_GAME),
850
	ConfigSetting("Custom14Mapping", "Custom14Image", "Custom14Shape", "Custom14Toggle", "Custom14Repeat", &g_Config.CustomButton[14], {0, 4, 2, false, false}, CfgFlag::PER_GAME),
851
	ConfigSetting("Custom15Mapping", "Custom15Image", "Custom15Shape", "Custom15Toggle", "Custom15Repeat", &g_Config.CustomButton[15], {0, 0, 9, false, false}, CfgFlag::PER_GAME),
852
	ConfigSetting("Custom16Mapping", "Custom16Image", "Custom16Shape", "Custom16Toggle", "Custom16Repeat", &g_Config.CustomButton[16], {0, 1, 9, false, false}, CfgFlag::PER_GAME),
853
	ConfigSetting("Custom17Mapping", "Custom17Image", "Custom17Shape", "Custom17Toggle", "Custom17Repeat", &g_Config.CustomButton[17], {0, 2, 9, false, false}, CfgFlag::PER_GAME),
854
	ConfigSetting("Custom18Mapping", "Custom18Image", "Custom18Shape", "Custom18Toggle", "Custom18Repeat", &g_Config.CustomButton[18], {0, 3, 9, false, false}, CfgFlag::PER_GAME),
855
	ConfigSetting("Custom19Mapping", "Custom19Image", "Custom19Shape", "Custom19Toggle", "Custom19Repeat", &g_Config.CustomButton[19], {0, 4, 9, false, false}, CfgFlag::PER_GAME),
856
	// Combo keys are something else, but I don't want to break the config backwards compatibility so these will stay wrongly named.
857
	ConfigSetting("fcombo0X", "fcombo0Y", "comboKeyScale0", "ShowComboKey0", &g_Config.touchCustom[0], defaultTouchPosHide, CfgFlag::PER_GAME),
858
	ConfigSetting("fcombo1X", "fcombo1Y", "comboKeyScale1", "ShowComboKey1", &g_Config.touchCustom[1], defaultTouchPosHide, CfgFlag::PER_GAME),
859
	ConfigSetting("fcombo2X", "fcombo2Y", "comboKeyScale2", "ShowComboKey2", &g_Config.touchCustom[2], defaultTouchPosHide, CfgFlag::PER_GAME),
860
	ConfigSetting("fcombo3X", "fcombo3Y", "comboKeyScale3", "ShowComboKey3", &g_Config.touchCustom[3], defaultTouchPosHide, CfgFlag::PER_GAME),
861
	ConfigSetting("fcombo4X", "fcombo4Y", "comboKeyScale4", "ShowComboKey4", &g_Config.touchCustom[4], defaultTouchPosHide, CfgFlag::PER_GAME),
862
	ConfigSetting("fcombo5X", "fcombo5Y", "comboKeyScale5", "ShowComboKey5", &g_Config.touchCustom[5], defaultTouchPosHide, CfgFlag::PER_GAME),
863
	ConfigSetting("fcombo6X", "fcombo6Y", "comboKeyScale6", "ShowComboKey6", &g_Config.touchCustom[6], defaultTouchPosHide, CfgFlag::PER_GAME),
864
	ConfigSetting("fcombo7X", "fcombo7Y", "comboKeyScale7", "ShowComboKey7", &g_Config.touchCustom[7], defaultTouchPosHide, CfgFlag::PER_GAME),
865
	ConfigSetting("fcombo8X", "fcombo8Y", "comboKeyScale8", "ShowComboKey8", &g_Config.touchCustom[8], defaultTouchPosHide, CfgFlag::PER_GAME),
866
	ConfigSetting("fcombo9X", "fcombo9Y", "comboKeyScale9", "ShowComboKey9", &g_Config.touchCustom[9], defaultTouchPosHide, CfgFlag::PER_GAME),
867
	ConfigSetting("fcombo10X", "fcombo10Y", "comboKeyScale10", "ShowComboKey10", &g_Config.touchCustom[10], defaultTouchPosHide, CfgFlag::PER_GAME),
868
	ConfigSetting("fcombo11X", "fcombo11Y", "comboKeyScale11", "ShowComboKey11", &g_Config.touchCustom[11], defaultTouchPosHide, CfgFlag::PER_GAME),
869
	ConfigSetting("fcombo12X", "fcombo12Y", "comboKeyScale12", "ShowComboKey12", &g_Config.touchCustom[12], defaultTouchPosHide, CfgFlag::PER_GAME),
870
	ConfigSetting("fcombo13X", "fcombo13Y", "comboKeyScale13", "ShowComboKey13", &g_Config.touchCustom[13], defaultTouchPosHide, CfgFlag::PER_GAME),
871
	ConfigSetting("fcombo14X", "fcombo14Y", "comboKeyScale14", "ShowComboKey14", &g_Config.touchCustom[14], defaultTouchPosHide, CfgFlag::PER_GAME),
872
	ConfigSetting("fcombo15X", "fcombo15Y", "comboKeyScale15", "ShowComboKey15", &g_Config.touchCustom[15], defaultTouchPosHide, CfgFlag::PER_GAME),
873
	ConfigSetting("fcombo16X", "fcombo16Y", "comboKeyScale16", "ShowComboKey16", &g_Config.touchCustom[16], defaultTouchPosHide, CfgFlag::PER_GAME),
874
	ConfigSetting("fcombo17X", "fcombo17Y", "comboKeyScale17", "ShowComboKey17", &g_Config.touchCustom[17], defaultTouchPosHide, CfgFlag::PER_GAME),
875
	ConfigSetting("fcombo18X", "fcombo18Y", "comboKeyScale18", "ShowComboKey18", &g_Config.touchCustom[18], defaultTouchPosHide, CfgFlag::PER_GAME),
876
	ConfigSetting("fcombo19X", "fcombo19Y", "comboKeyScale19", "ShowComboKey19", &g_Config.touchCustom[19], defaultTouchPosHide, CfgFlag::PER_GAME),
877

878
	// A win32 user seeing touch controls is likely using PPSSPP on a tablet. There it makes
879
	// sense to default this to on.
880
	ConfigSetting("ShowTouchPause", &g_Config.bShowTouchPause, &DefaultShowPauseButton, CfgFlag::DEFAULT),
881
#if defined(USING_WIN_UI)
882
	ConfigSetting("IgnoreWindowsKey", &g_Config.bIgnoreWindowsKey, false, CfgFlag::PER_GAME),
883
#endif
884

885
	ConfigSetting("ShowTouchControls", &g_Config.bShowTouchControls, &DefaultShowTouchControls, CfgFlag::PER_GAME),
886

887
	// ConfigSetting("KeyMapping", &g_Config.iMappingMap, 0),
888

889
#ifdef MOBILE_DEVICE
890
	ConfigSetting("TiltBaseAngleY", &g_Config.fTiltBaseAngleY, 0.9f, CfgFlag::PER_GAME),
891
	ConfigSetting("TiltInvertX", &g_Config.bInvertTiltX, false, CfgFlag::PER_GAME),
892
	ConfigSetting("TiltInvertY", &g_Config.bInvertTiltY, false, CfgFlag::PER_GAME),
893
	ConfigSetting("TiltSensitivityX", &g_Config.iTiltSensitivityX, 60, CfgFlag::PER_GAME),
894
	ConfigSetting("TiltSensitivityY", &g_Config.iTiltSensitivityY, 60, CfgFlag::PER_GAME),
895
	ConfigSetting("TiltAnalogDeadzoneRadius", &g_Config.fTiltAnalogDeadzoneRadius, 0.0f, CfgFlag::PER_GAME),
896
	ConfigSetting("TiltInverseDeadzone", &g_Config.fTiltInverseDeadzone, 0.0f, CfgFlag::PER_GAME),
897
	ConfigSetting("TiltCircularDeadzone", &g_Config.bTiltCircularDeadzone, true, CfgFlag::PER_GAME),
898
	ConfigSetting("TiltInputType", &g_Config.iTiltInputType, 0, CfgFlag::PER_GAME),
899
#endif
900

901
	ConfigSetting("DisableDpadDiagonals", &g_Config.bDisableDpadDiagonals, false, CfgFlag::PER_GAME),
902
	ConfigSetting("GamepadOnlyFocused", &g_Config.bGamepadOnlyFocused, false, CfgFlag::PER_GAME),
903
	ConfigSetting("TouchButtonStyle", &g_Config.iTouchButtonStyle, 1, CfgFlag::PER_GAME),
904
	ConfigSetting("TouchButtonOpacity", &g_Config.iTouchButtonOpacity, 65, CfgFlag::PER_GAME),
905
	ConfigSetting("TouchButtonHideSeconds", &g_Config.iTouchButtonHideSeconds, 20, CfgFlag::PER_GAME),
906
	ConfigSetting("AutoCenterTouchAnalog", &g_Config.bAutoCenterTouchAnalog, false, CfgFlag::PER_GAME),
907
	ConfigSetting("StickyTouchDPad", &g_Config.bStickyTouchDPad, false, CfgFlag::PER_GAME),
908

909
	// Snap touch control position
910
	ConfigSetting("TouchSnapToGrid", &g_Config.bTouchSnapToGrid, false, CfgFlag::PER_GAME),
911
	ConfigSetting("TouchSnapGridSize", &g_Config.iTouchSnapGridSize, 64, CfgFlag::PER_GAME),
912

913
	// -1.0f means uninitialized, set in GamepadEmu::CreatePadLayout().
914
	ConfigSetting("ActionButtonSpacing2", &g_Config.fActionButtonSpacing, 1.0f, CfgFlag::PER_GAME),
915
	ConfigSetting("ActionButtonCenterX", "ActionButtonCenterY", "ActionButtonScale", nullptr, &g_Config.touchActionButtonCenter, defaultTouchPosShow, CfgFlag::PER_GAME),
916
	ConfigSetting("DPadX", "DPadY", "DPadScale", "ShowTouchDpad", &g_Config.touchDpad, defaultTouchPosShow, CfgFlag::PER_GAME),
917

918
	// Note: these will be overwritten if DPadRadius is set.
919
	ConfigSetting("DPadSpacing", &g_Config.fDpadSpacing, 1.0f, CfgFlag::PER_GAME),
920
	ConfigSetting("StartKeyX", "StartKeyY", "StartKeyScale", "ShowTouchStart", &g_Config.touchStartKey, defaultTouchPosShow, CfgFlag::PER_GAME),
921
	ConfigSetting("SelectKeyX", "SelectKeyY", "SelectKeyScale", "ShowTouchSelect", &g_Config.touchSelectKey, defaultTouchPosShow, CfgFlag::PER_GAME),
922
	ConfigSetting("UnthrottleKeyX", "UnthrottleKeyY", "UnthrottleKeyScale", "ShowTouchUnthrottle", &g_Config.touchFastForwardKey, defaultTouchPosShow, CfgFlag::PER_GAME),
923
	ConfigSetting("LKeyX", "LKeyY", "LKeyScale", "ShowTouchLTrigger", &g_Config.touchLKey, defaultTouchPosShow, CfgFlag::PER_GAME),
924
	ConfigSetting("RKeyX", "RKeyY", "RKeyScale", "ShowTouchRTrigger", &g_Config.touchRKey, defaultTouchPosShow, CfgFlag::PER_GAME),
925
	ConfigSetting("AnalogStickX", "AnalogStickY", "AnalogStickScale", "ShowAnalogStick", &g_Config.touchAnalogStick, defaultTouchPosShow, CfgFlag::PER_GAME),
926
	ConfigSetting("RightAnalogStickX", "RightAnalogStickY", "RightAnalogStickScale", "ShowRightAnalogStick", &g_Config.touchRightAnalogStick, defaultTouchPosHide, CfgFlag::PER_GAME),
927

928
	ConfigSetting("AnalogDeadzone", &g_Config.fAnalogDeadzone, 0.15f, CfgFlag::PER_GAME),
929
	ConfigSetting("AnalogInverseDeadzone", &g_Config.fAnalogInverseDeadzone, 0.0f, CfgFlag::PER_GAME),
930
	ConfigSetting("AnalogSensitivity", &g_Config.fAnalogSensitivity, 1.1f, CfgFlag::PER_GAME),
931
	ConfigSetting("AnalogIsCircular", &g_Config.bAnalogIsCircular, false, CfgFlag::PER_GAME),
932
	ConfigSetting("AnalogAutoRotSpeed", &g_Config.fAnalogAutoRotSpeed, 8.0f, CfgFlag::PER_GAME),
933

934
	ConfigSetting("AnalogLimiterDeadzone", &g_Config.fAnalogLimiterDeadzone, 0.6f, CfgFlag::DEFAULT),
935
	ConfigSetting("AnalogTriggerThreshold", &g_Config.fAnalogTriggerThreshold, 0.75f, CfgFlag::DEFAULT),
936

937
	ConfigSetting("AllowMappingCombos", &g_Config.bAllowMappingCombos, false, CfgFlag::DEFAULT),
938
	ConfigSetting("StrictComboOrder", &g_Config.bStrictComboOrder, false, CfgFlag::DEFAULT),
939

940
	ConfigSetting("LeftStickHeadScale", &g_Config.fLeftStickHeadScale, 1.0f, CfgFlag::PER_GAME),
941
	ConfigSetting("RightStickHeadScale", &g_Config.fRightStickHeadScale, 1.0f, CfgFlag::PER_GAME),
942
	ConfigSetting("HideStickBackground", &g_Config.bHideStickBackground, false, CfgFlag::PER_GAME),
943

944
	ConfigSetting("UseMouse", &g_Config.bMouseControl, false, CfgFlag::PER_GAME),
945
	ConfigSetting("ConfineMap", &g_Config.bMouseConfine, false, CfgFlag::PER_GAME),
946
	ConfigSetting("MouseSensitivity", &g_Config.fMouseSensitivity, 0.1f, CfgFlag::PER_GAME),
947
	ConfigSetting("MouseSmoothing", &g_Config.fMouseSmoothing, 0.9f, CfgFlag::PER_GAME),
948
	ConfigSetting("MouseWheelUpDelayMs", &g_Config.iMouseWheelUpDelayMs, 80, CfgFlag::PER_GAME),
949

950
	ConfigSetting("SystemControls", &g_Config.bSystemControls, true, CfgFlag::DEFAULT),
951
	ConfigSetting("RapidFileInterval", &g_Config.iRapidFireInterval, 5, CfgFlag::DEFAULT),
952

953
	ConfigSetting("AnalogGesture", &g_Config.bAnalogGesture, false, CfgFlag::PER_GAME),
954
	ConfigSetting("AnalogGestureSensibility", &g_Config.fAnalogGestureSensibility, 1.0f, CfgFlag::PER_GAME),
955
};
956

957
static const ConfigSetting networkSettings[] = {
958
	ConfigSetting("EnableWlan", &g_Config.bEnableWlan, false, CfgFlag::PER_GAME),
959
	ConfigSetting("EnableAdhocServer", &g_Config.bEnableAdhocServer, false, CfgFlag::PER_GAME),
960
	ConfigSetting("proAdhocServer", &g_Config.proAdhocServer, "socom.cc", CfgFlag::PER_GAME),
961
	ConfigSetting("PortOffset", &g_Config.iPortOffset, 10000, CfgFlag::PER_GAME),
962
	ConfigSetting("PrimaryDNSServer", &g_Config.sInfrastructureDNSServer, "67.222.156.250", CfgFlag::PER_GAME),
963
	ConfigSetting("MinTimeout", &g_Config.iMinTimeout, 0, CfgFlag::PER_GAME),
964
	ConfigSetting("ForcedFirstConnect", &g_Config.bForcedFirstConnect, false, CfgFlag::PER_GAME),
965
	ConfigSetting("EnableUPnP", &g_Config.bEnableUPnP, false, CfgFlag::PER_GAME),
966
	ConfigSetting("UPnPUseOriginalPort", &g_Config.bUPnPUseOriginalPort, false, CfgFlag::PER_GAME),
967
	ConfigSetting("InfrastructureUsername", &g_Config.sInfrastructureUsername, &DefaultInfrastructureUsername, CfgFlag::PER_GAME),
968
	ConfigSetting("InfrastructureAutoDNS", &g_Config.bInfrastructureAutoDNS, true, CfgFlag::PER_GAME),
969
	ConfigSetting("AllowSavestateWhileConnected", &g_Config.bAllowSavestateWhileConnected, false, CfgFlag::DONT_SAVE),
970
	ConfigSetting("AllowSpeedControlWhileConnected", &g_Config.bAllowSpeedControlWhileConnected, false, CfgFlag::PER_GAME),
971
	ConfigSetting("DontDownloadInfraJson", &g_Config.bDontDownloadInfraJson, false, CfgFlag::DONT_SAVE),
972

973
	ConfigSetting("EnableNetworkChat", &g_Config.bEnableNetworkChat, false, CfgFlag::PER_GAME),
974
	ConfigSetting("ChatButtonPosition", &g_Config.iChatButtonPosition, (int)ScreenEdgePosition::BOTTOM_LEFT, CfgFlag::PER_GAME),
975
	ConfigSetting("ChatScreenPosition", &g_Config.iChatScreenPosition, (int)ScreenEdgePosition::BOTTOM_LEFT, CfgFlag::PER_GAME),
976
	ConfigSetting("EnableQuickChat", &g_Config.bEnableQuickChat, true, CfgFlag::PER_GAME),
977
	ConfigSetting("QuickChat1", &g_Config.sQuickChat0, "Quick Chat 1", CfgFlag::PER_GAME),
978
	ConfigSetting("QuickChat2", &g_Config.sQuickChat1, "Quick Chat 2", CfgFlag::PER_GAME),
979
	ConfigSetting("QuickChat3", &g_Config.sQuickChat2, "Quick Chat 3", CfgFlag::PER_GAME),
980
	ConfigSetting("QuickChat4", &g_Config.sQuickChat3, "Quick Chat 4", CfgFlag::PER_GAME),
981
	ConfigSetting("QuickChat5", &g_Config.sQuickChat4, "Quick Chat 5", CfgFlag::PER_GAME),
982
};
983

984
static const ConfigSetting systemParamSettings[] = {
985
	ConfigSetting("PSPModel", &g_Config.iPSPModel, PSP_MODEL_SLIM, CfgFlag::PER_GAME | CfgFlag::REPORT),
986
	ConfigSetting("PSPFirmwareVersion", &g_Config.iFirmwareVersion, PSP_DEFAULT_FIRMWARE, CfgFlag::PER_GAME | CfgFlag::REPORT),
987
	ConfigSetting("NickName", &g_Config.sNickName, "PPSSPP", CfgFlag::PER_GAME),
988
	ConfigSetting("MacAddress", &g_Config.sMACAddress, "", CfgFlag::PER_GAME),
989
	ConfigSetting("GameLanguage", &g_Config.iLanguage, -1, CfgFlag::PER_GAME | CfgFlag::REPORT),
990
	ConfigSetting("ParamTimeFormat", &g_Config.iTimeFormat, PSP_SYSTEMPARAM_TIME_FORMAT_24HR, CfgFlag::PER_GAME),
991
	ConfigSetting("ParamDateFormat", &g_Config.iDateFormat, PSP_SYSTEMPARAM_DATE_FORMAT_YYYYMMDD, CfgFlag::PER_GAME),
992
	ConfigSetting("TimeZone", &g_Config.iTimeZone, 0, CfgFlag::PER_GAME),
993
	ConfigSetting("DayLightSavings", &g_Config.bDayLightSavings, (bool) PSP_SYSTEMPARAM_DAYLIGHTSAVINGS_STD, CfgFlag::PER_GAME),
994
	ConfigSetting("ButtonPreference", &g_Config.iButtonPreference, PSP_SYSTEMPARAM_BUTTON_CROSS, CfgFlag::PER_GAME | CfgFlag::REPORT),
995
	ConfigSetting("LockParentalLevel", &g_Config.iLockParentalLevel, 0, CfgFlag::PER_GAME),
996
	ConfigSetting("WlanAdhocChannel", &g_Config.iWlanAdhocChannel, PSP_SYSTEMPARAM_ADHOC_CHANNEL_AUTOMATIC, CfgFlag::PER_GAME),
997
#if defined(USING_WIN_UI) || defined(USING_QT_UI) || PPSSPP_PLATFORM(ANDROID) || PPSSPP_PLATFORM(SWITCH)
998
	ConfigSetting("BypassOSKWithKeyboard", &g_Config.bBypassOSKWithKeyboard, false, CfgFlag::PER_GAME),
999
#endif
1000
	ConfigSetting("WlanPowerSave", &g_Config.bWlanPowerSave, (bool) PSP_SYSTEMPARAM_WLAN_POWERSAVE_OFF, CfgFlag::PER_GAME),
1001
	ConfigSetting("EncryptSave", &g_Config.bEncryptSave, true, CfgFlag::PER_GAME | CfgFlag::REPORT),
1002
	ConfigSetting("MemStickSize", &g_Config.iMemStickSizeGB, 16, CfgFlag::DEFAULT),
1003
};
1004

1005
static const ConfigSetting debuggerSettings[] = {
1006
	ConfigSetting("DisasmWindowX", &g_Config.iDisasmWindowX, -1, CfgFlag::DEFAULT),
1007
	ConfigSetting("DisasmWindowY", &g_Config.iDisasmWindowY, -1, CfgFlag::DEFAULT),
1008
	ConfigSetting("DisasmWindowW", &g_Config.iDisasmWindowW, -1, CfgFlag::DEFAULT),
1009
	ConfigSetting("DisasmWindowH", &g_Config.iDisasmWindowH, -1, CfgFlag::DEFAULT),
1010
	ConfigSetting("GEWindowX", &g_Config.iGEWindowX, -1, CfgFlag::DEFAULT),
1011
	ConfigSetting("GEWindowY", &g_Config.iGEWindowY, -1, CfgFlag::DEFAULT),
1012
	ConfigSetting("GEWindowW", &g_Config.iGEWindowW, -1, CfgFlag::DEFAULT),
1013
	ConfigSetting("GEWindowH", &g_Config.iGEWindowH, -1, CfgFlag::DEFAULT),
1014
	ConfigSetting("GEWindowTabsBL", &g_Config.uGETabsLeft, (uint32_t)0, CfgFlag::DEFAULT),
1015
	ConfigSetting("GEWindowTabsBR", &g_Config.uGETabsRight, (uint32_t)0, CfgFlag::DEFAULT),
1016
	ConfigSetting("GEWindowTabsTR", &g_Config.uGETabsTopRight, (uint32_t)0, CfgFlag::DEFAULT),
1017
	ConfigSetting("ConsoleWindowX", &g_Config.iConsoleWindowX, -1, CfgFlag::DEFAULT),
1018
	ConfigSetting("ConsoleWindowY", &g_Config.iConsoleWindowY, -1, CfgFlag::DEFAULT),
1019
	ConfigSetting("FontWidth", &g_Config.iFontWidth, 8, CfgFlag::DEFAULT),
1020
	ConfigSetting("FontHeight", &g_Config.iFontHeight, 12, CfgFlag::DEFAULT),
1021
	ConfigSetting("DisplayStatusBar", &g_Config.bDisplayStatusBar, true, CfgFlag::DEFAULT),
1022
	ConfigSetting("ShowBottomTabTitles",&g_Config.bShowBottomTabTitles, true, CfgFlag::DEFAULT),
1023
	ConfigSetting("ShowDeveloperMenu", &g_Config.bShowDeveloperMenu, false, CfgFlag::DEFAULT),
1024
	ConfigSetting("SkipDeadbeefFilling", &g_Config.bSkipDeadbeefFilling, false, CfgFlag::DEFAULT),
1025
	ConfigSetting("FuncHashMap", &g_Config.bFuncHashMap, false, CfgFlag::DEFAULT),
1026
	ConfigSetting("SkipFuncHashMap", &g_Config.sSkipFuncHashMap, "", CfgFlag::DEFAULT),
1027
	ConfigSetting("MemInfoDetailed", &g_Config.bDebugMemInfoDetailed, false, CfgFlag::DEFAULT),
1028
};
1029

1030
static const ConfigSetting jitSettings[] = {
1031
	ConfigSetting("DiscardRegsOnJRRA", &g_Config.bDiscardRegsOnJRRA, false, CfgFlag::DONT_SAVE | CfgFlag::REPORT),
1032
};
1033

1034
static const ConfigSetting themeSettings[] = {
1035
	ConfigSetting("ThemeName", &g_Config.sThemeName, "Default", CfgFlag::DEFAULT),
1036
};
1037

1038

1039
static const ConfigSetting vrSettings[] = {
1040
	ConfigSetting("VREnable", &g_Config.bEnableVR, true, CfgFlag::PER_GAME),
1041
	ConfigSetting("VREnable6DoF", &g_Config.bEnable6DoF, false, CfgFlag::PER_GAME),
1042
	ConfigSetting("VREnableStereo", &g_Config.bEnableStereo, false, CfgFlag::PER_GAME),
1043
	ConfigSetting("VRForce72Hz", &g_Config.bForce72Hz, true, CfgFlag::PER_GAME),
1044
	ConfigSetting("VRForce", &g_Config.bForceVR, false, CfgFlag::DEFAULT),
1045
	ConfigSetting("VRImmersiveMode", &g_Config.bEnableImmersiveVR, true, CfgFlag::PER_GAME),
1046
	ConfigSetting("VRManualForceVR", &g_Config.bManualForceVR, false, CfgFlag::PER_GAME),
1047
	ConfigSetting("VRPassthrough", &g_Config.bPassthrough, false, CfgFlag::PER_GAME),
1048
	ConfigSetting("VRRescaleHUD", &g_Config.bRescaleHUD, true, CfgFlag::PER_GAME),
1049
	ConfigSetting("VRCameraDistance", &g_Config.fCameraDistance, 0.0f, CfgFlag::PER_GAME),
1050
	ConfigSetting("VRCameraHeight", &g_Config.fCameraHeight, 0.0f, CfgFlag::PER_GAME),
1051
	ConfigSetting("VRCameraSide", &g_Config.fCameraSide, 0.0f, CfgFlag::PER_GAME),
1052
	ConfigSetting("VRCameraPitch", &g_Config.fCameraPitch, 0.0f, CfgFlag::PER_GAME),
1053
	ConfigSetting("VRCanvasDistance", &g_Config.fCanvasDistance, 12.0f, CfgFlag::DEFAULT),
1054
	ConfigSetting("VRCanvas3DDistance", &g_Config.fCanvas3DDistance, 3.0f, CfgFlag::DEFAULT),
1055
	ConfigSetting("VRFieldOfView", &g_Config.fFieldOfViewPercentage, 100.0f, CfgFlag::PER_GAME),
1056
	ConfigSetting("VRHeadUpDisplayScale", &g_Config.fHeadUpDisplayScale, 0.3f, CfgFlag::PER_GAME),
1057
};
1058

1059
static const ConfigSectionSettings sections[] = {
1060
	{"General", generalSettings, ARRAY_SIZE(generalSettings)},
1061
	{"CPU", cpuSettings, ARRAY_SIZE(cpuSettings)},
1062
	{"Graphics", graphicsSettings, ARRAY_SIZE(graphicsSettings)},
1063
	{"Sound", soundSettings, ARRAY_SIZE(soundSettings)},
1064
	{"Control", controlSettings, ARRAY_SIZE(controlSettings)},
1065
	{"SystemParam", systemParamSettings, ARRAY_SIZE(systemParamSettings)},
1066
	{"Network", networkSettings, ARRAY_SIZE(networkSettings)},
1067
	{"Debugger", debuggerSettings, ARRAY_SIZE(debuggerSettings)},
1068
	{"JIT", jitSettings, ARRAY_SIZE(jitSettings)},
1069
	{"Theme", themeSettings, ARRAY_SIZE(themeSettings)},
1070
	{"VR", vrSettings, ARRAY_SIZE(vrSettings)},
1071
	{"Achievements", achievementSettings, ARRAY_SIZE(achievementSettings)},
1072
};
1073

1074
const size_t numSections = ARRAY_SIZE(sections);
1075

1076
static void IterateSettings(IniFile &iniFile, std::function<void(Section *section, const ConfigSetting &setting)> func) {
1077
	for (size_t i = 0; i < numSections; ++i) {
1078
		Section *section = iniFile.GetOrCreateSection(sections[i].section);
1079
		for (size_t j = 0; j < sections[i].settingsCount; j++) {
1080
			func(section, sections[i].settings[j]);
1081
		}
1082
	}
1083
}
1084

1085
static void IterateSettings(std::function<void(const ConfigSetting &setting)> func) {
1086
	for (size_t i = 0; i < numSections; ++i) {
1087
		for (size_t j = 0; j < sections[i].settingsCount; j++) {
1088
			func(sections[i].settings[j]);
1089
		}
1090
	}
1091
}
1092

1093
Config::Config() {}
1094

1095
Config::~Config() {
1096
	if (bUpdatedInstanceCounter) {
1097
		ShutdownInstanceCounter();
1098
	}
1099
}
1100

1101
void Config::LoadLangValuesMapping() {
1102
	IniFile mapping;
1103
	mapping.LoadFromVFS(g_VFS, "langregion.ini");
1104
	std::vector<std::string> keys;
1105
	mapping.GetKeys("LangRegionNames", keys);
1106

1107
	std::map<std::string, int> langCodeMapping;
1108
	langCodeMapping["JAPANESE"] = PSP_SYSTEMPARAM_LANGUAGE_JAPANESE;
1109
	langCodeMapping["ENGLISH"] = PSP_SYSTEMPARAM_LANGUAGE_ENGLISH;
1110
	langCodeMapping["FRENCH"] = PSP_SYSTEMPARAM_LANGUAGE_FRENCH;
1111
	langCodeMapping["SPANISH"] = PSP_SYSTEMPARAM_LANGUAGE_SPANISH;
1112
	langCodeMapping["GERMAN"] = PSP_SYSTEMPARAM_LANGUAGE_GERMAN;
1113
	langCodeMapping["ITALIAN"] = PSP_SYSTEMPARAM_LANGUAGE_ITALIAN;
1114
	langCodeMapping["DUTCH"] = PSP_SYSTEMPARAM_LANGUAGE_DUTCH;
1115
	langCodeMapping["PORTUGUESE"] = PSP_SYSTEMPARAM_LANGUAGE_PORTUGUESE;
1116
	langCodeMapping["RUSSIAN"] = PSP_SYSTEMPARAM_LANGUAGE_RUSSIAN;
1117
	langCodeMapping["KOREAN"] = PSP_SYSTEMPARAM_LANGUAGE_KOREAN;
1118
	langCodeMapping["CHINESE_TRADITIONAL"] = PSP_SYSTEMPARAM_LANGUAGE_CHINESE_TRADITIONAL;
1119
	langCodeMapping["CHINESE_SIMPLIFIED"] = PSP_SYSTEMPARAM_LANGUAGE_CHINESE_SIMPLIFIED;
1120

1121
	const Section *langRegionNames = mapping.GetOrCreateSection("LangRegionNames");
1122
	const Section *systemLanguage = mapping.GetOrCreateSection("SystemLanguage");
1123

1124
	for (size_t i = 0; i < keys.size(); i++) {
1125
		std::string langName;
1126
		langRegionNames->Get(keys[i], &langName, "ERROR");
1127
		std::string langCode;
1128
		systemLanguage->Get(keys[i], &langCode, "ENGLISH");
1129
		int iLangCode = PSP_SYSTEMPARAM_LANGUAGE_ENGLISH;
1130
		if (langCodeMapping.find(langCode) != langCodeMapping.end())
1131
			iLangCode = langCodeMapping[langCode];
1132
		langValuesMapping_[keys[i]] = std::make_pair(langName, iLangCode);
1133
	}
1134
}
1135

1136
const std::map<std::string, std::pair<std::string, int>, std::less<>> &Config::GetLangValuesMapping() {
1137
	if (langValuesMapping_.empty()) {
1138
		LoadLangValuesMapping();
1139
	}
1140
	return langValuesMapping_;
1141
}
1142

1143
void Config::Reload() {
1144
	reload_ = true;
1145
	Load();
1146
	reload_ = false;
1147
}
1148

1149
// Call this if you change the search path (such as when changing memstick directory. can't
1150
// really think of any other legit uses).
1151
void Config::UpdateIniLocation(const char *iniFileName, const char *controllerIniFilename) {
1152
	const bool useIniFilename = iniFileName != nullptr && strlen(iniFileName) > 0;
1153
	const char *ppssppIniFilename = IsVREnabled() ? "ppssppvr.ini" : "ppsspp.ini";
1154
	bool exists;
1155
	iniFilename_ = FindConfigFile(useIniFilename ? iniFileName : ppssppIniFilename, &exists);
1156
	const bool useControllerIniFilename = controllerIniFilename != nullptr && strlen(controllerIniFilename) > 0;
1157
	const char *controlsIniFilename = IsVREnabled() ? "controlsvr.ini" : "controls.ini";
1158
	controllerIniFilename_ = FindConfigFile(useControllerIniFilename ? controllerIniFilename : controlsIniFilename, &exists);
1159
}
1160

1161
bool Config::LoadAppendedConfig() {
1162
	IniFile iniFile;
1163
	if (!iniFile.Load(appendedConfigFileName_)) {
1164
		ERROR_LOG(Log::Loader, "Failed to read appended config '%s'.", appendedConfigFileName_.c_str());
1165
		return false;
1166
	}
1167

1168
	IterateSettings(iniFile, [&iniFile](Section *section, const ConfigSetting &setting) {
1169
		if (iniFile.Exists(section->name().c_str(), setting.iniKey_))
1170
			setting.Get(section);
1171
	});
1172

1173
	INFO_LOG(Log::Loader, "Loaded appended config '%s'.", appendedConfigFileName_.c_str());
1174

1175
	Save("Loaded appended config"); // Let's prevent reset
1176
	return true;
1177
}
1178

1179
void Config::SetAppendedConfigIni(const Path &path) {
1180
	appendedConfigFileName_ = path;
1181
}
1182

1183
void Config::UpdateAfterSettingAutoFrameSkip() {
1184
	if (bAutoFrameSkip && iFrameSkip == 0) {
1185
		iFrameSkip = 1;
1186
	}
1187
	
1188
	if (bAutoFrameSkip && bSkipBufferEffects) {
1189
		bSkipBufferEffects = false;
1190
	}
1191
}
1192

1193
void Config::Load(const char *iniFileName, const char *controllerIniFilename) {
1194
	double startTime = time_now_d();
1195

1196
	if (!bUpdatedInstanceCounter) {
1197
		InitInstanceCounter();
1198
		bUpdatedInstanceCounter = true;
1199
	}
1200

1201
	g_DownloadManager.SetUserAgent(StringFromFormat("PPSSPP/%s", PPSSPP_GIT_VERSION));
1202

1203
	UpdateIniLocation(iniFileName, controllerIniFilename);
1204

1205
	INFO_LOG(Log::Loader, "Loading config: %s", iniFilename_.c_str());
1206
	bSaveSettings = true;
1207

1208
	IniFile iniFile;
1209
	if (!iniFile.Load(iniFilename_)) {
1210
		ERROR_LOG(Log::Loader, "Failed to read '%s'. Setting config to default.", iniFilename_.c_str());
1211
		// Continue anyway to initialize the config.
1212
	}
1213

1214
	IterateSettings(iniFile, [](Section *section, const ConfigSetting &setting) {
1215
		setting.Get(section);
1216
	});
1217

1218
	iRunCount++;
1219

1220
	// For iOS, issue #19211
1221
	TryUpdateSavedPath(&currentDirectory);
1222

1223
	Section *log = iniFile.GetOrCreateSection(logSectionName);
1224

1225
	g_logManager.LoadConfig(log);
1226

1227
	Section *recent = iniFile.GetOrCreateSection("Recent");
1228
	recent->Get("MaxRecent", &iMaxRecent, 60);
1229

1230
	// Fix issue from switching from uint (hex in .ini) to int (dec)
1231
	// -1 is okay, though. We'll just ignore recent stuff if it is.
1232
	if (iMaxRecent == 0)
1233
		iMaxRecent = 60;
1234

1235
	// Fix JIT setting if no longer available.
1236
	if (!System_GetPropertyBool(SYSPROP_CAN_JIT)) {
1237
		if (iCpuCore == (int)CPUCore::JIT || iCpuCore == (int)CPUCore::JIT_IR) {
1238
			WARN_LOG(Log::Loader, "Forcing JIT off due to unavailablility");
1239
			iCpuCore = (int)CPUCore::IR_INTERPRETER;
1240
		}
1241
	}
1242

1243
	if (iGPUBackend == 1) {  // d3d9, no longer supported
1244
		iGPUBackend = 2;  // d3d11
1245
	}
1246

1247
	if (iMaxRecent > 0) {
1248
		g_recentFiles.Load(recent, iMaxRecent);
1249
	}
1250

1251
	// Time tracking
1252
	Section *playTime = iniFile.GetOrCreateSection("PlayTime");
1253
	playTimeTracker_.Load(playTime);
1254

1255
	auto pinnedPaths = iniFile.GetOrCreateSection("PinnedPaths")->ToMap();
1256
	vPinnedPaths.clear();
1257
	for (const auto &[_, value] : pinnedPaths) {
1258
		// Unpin paths that are deleted automatically.
1259
		const std::string &path = value;
1260
		if (startsWith(path, "http://") || startsWith(path, "https://") || File::Exists(Path(path))) {
1261
			vPinnedPaths.push_back(File::ResolvePath(path));
1262
		}
1263
	}
1264

1265
	// Default values for post process shaders
1266
	bool postShadersInitialized = iniFile.HasSection("PostShaderList");
1267
	Section *postShaderChain = iniFile.GetOrCreateSection("PostShaderList");
1268
	Section *postShaderSetting = iniFile.GetOrCreateSection("PostShaderSetting");
1269
	if (IsVREnabled() && !postShadersInitialized) {
1270
		postShaderChain->Set("PostShader1", "ColorCorrection");
1271
		postShaderSetting->Set("ColorCorrectionSettingCurrentValue1", 1.0f);
1272
		postShaderSetting->Set("ColorCorrectionSettingCurrentValue2", 1.5f);
1273
		postShaderSetting->Set("ColorCorrectionSettingCurrentValue3", 1.1f);
1274
		postShaderSetting->Set("ColorCorrectionSettingCurrentValue4", 1.0f);
1275
	}
1276

1277
	// Load post process shader values
1278
	mPostShaderSetting.clear();
1279
	for (const auto &[key, value] : postShaderSetting->ToMap()) {
1280
		mPostShaderSetting[key] = std::stof(value);
1281
	}
1282

1283
	const Section *hostOverrideSetting = iniFile.GetOrCreateSection("HostAliases");
1284
	// TODO: relocate me before PR
1285
	mHostToAlias = hostOverrideSetting->ToMap();
1286

1287
	// Load post process shader names
1288
	vPostShaderNames.clear();
1289
	for (const auto& it : postShaderChain->ToMap()) {
1290
		if (it.second != "Off")
1291
			vPostShaderNames.push_back(it.second);
1292
	}
1293

1294
	// Check for an old dpad setting (very obsolete)
1295
	Section *control = iniFile.GetSection("Control");
1296
	if (control) {
1297
		float f;
1298
		control->Get("DPadRadius", &f, 0.0f);
1299
		if (f > 0.0f) {
1300
			ResetControlLayout();
1301
		}
1302
	}
1303

1304
	// Force JIT setting to a valid value for the current system configuration.
1305
	if (!System_GetPropertyBool(SYSPROP_CAN_JIT)) {
1306
		if (g_Config.iCpuCore == (int)CPUCore::JIT || g_Config.iCpuCore == (int)CPUCore::JIT_IR) {
1307
			g_Config.iCpuCore = (int)CPUCore::IR_INTERPRETER;
1308
		}
1309
	}
1310

1311
	INFO_LOG(Log::Loader, "Loading controller config: %s", controllerIniFilename_.c_str());
1312
	bSaveSettings = true;
1313

1314
	LoadStandardControllerIni();
1315

1316
	//so this is all the way down here to overwrite the controller settings
1317
	//sadly it won't benefit from all the "version conversion" going on up-above
1318
	//but these configs shouldn't contain older versions anyhow
1319
	if (bGameSpecific) {
1320
		loadGameConfig(gameId_, gameIdTitle_);
1321
	}
1322

1323
	g_recentFiles.Clean();
1324

1325
	PostLoadCleanup(false);
1326

1327
	INFO_LOG(Log::Loader, "Config loaded: '%s' (%0.1f ms)", iniFilename_.c_str(), (time_now_d() - startTime) * 1000.0);
1328
}
1329

1330
bool Config::Save(const char *saveReason) {
1331
	double startTime = time_now_d();
1332
	if (!IsFirstInstance()) {
1333
		// TODO: Should we allow saving config if started from a different directory?
1334
		// How do we tell?
1335
		WARN_LOG(Log::Loader, "Not saving config - secondary instances don't.");
1336

1337
		// Don't want to retry or something.
1338
		return true;
1339
	}
1340

1341
	if (!iniFilename_.empty() && g_Config.bSaveSettings) {
1342
		saveGameConfig(gameId_, gameIdTitle_);
1343

1344
		PreSaveCleanup(false);
1345

1346
		g_recentFiles.Clean();
1347
		IniFile iniFile;
1348
		if (!iniFile.Load(iniFilename_)) {
1349
			WARN_LOG(Log::Loader, "Likely saving config for first time - couldn't read ini '%s'", iniFilename_.c_str());
1350
		}
1351

1352
		// Need to do this somewhere...
1353
		bFirstRun = false;
1354

1355
		IterateSettings(iniFile, [&](Section *section, const ConfigSetting &setting) {
1356
			if (!bGameSpecific || !setting.PerGame()) {
1357
				setting.Set(section);
1358
			}
1359
		});
1360

1361
		Section *recent = iniFile.GetOrCreateSection("Recent");
1362
		recent->Set("MaxRecent", iMaxRecent);
1363
		g_recentFiles.Save(recent, iMaxRecent);
1364

1365
		Section *pinnedPaths = iniFile.GetOrCreateSection("PinnedPaths");
1366
		pinnedPaths->Clear();
1367
		for (size_t i = 0; i < vPinnedPaths.size(); ++i) {
1368
			char keyName[64];
1369
			snprintf(keyName, sizeof(keyName), "Path%d", (int)i);
1370
			pinnedPaths->Set(keyName, vPinnedPaths[i]);
1371
		}
1372

1373
		if (!bGameSpecific) {
1374
			Section *postShaderSetting = iniFile.GetOrCreateSection("PostShaderSetting");
1375
			postShaderSetting->Clear();
1376
			for (const auto &[k, v] : mPostShaderSetting) {
1377
				postShaderSetting->Set(k, v);
1378
			}
1379
			Section *postShaderChain = iniFile.GetOrCreateSection("PostShaderList");
1380
			postShaderChain->Clear();
1381
			for (size_t i = 0; i < vPostShaderNames.size(); ++i) {
1382
				char keyName[64];
1383
				snprintf(keyName, sizeof(keyName), "PostShader%d", (int)i+1);
1384
				postShaderChain->Set(keyName, vPostShaderNames[i]);
1385
			}
1386
		}
1387

1388
		// TODO: relocate me before PR
1389
		Section *hostOverrideSetting = iniFile.GetOrCreateSection("HostAliases");
1390
		hostOverrideSetting->Clear();
1391
		for (auto& it : mHostToAlias) {
1392
			hostOverrideSetting->Set(it.first.c_str(), it.second.c_str());
1393
		}
1394

1395
		Section *control = iniFile.GetOrCreateSection("Control");
1396
		control->Delete("DPadRadius");
1397

1398
		Section *log = iniFile.GetOrCreateSection(logSectionName);
1399
		g_logManager.SaveConfig(log);
1400

1401
		// Time tracking
1402
		Section *playTime = iniFile.GetOrCreateSection("PlayTime");
1403
		playTimeTracker_.Save(playTime);
1404

1405
		if (!iniFile.Save(iniFilename_)) {
1406
			ERROR_LOG(Log::Loader, "Error saving config (%s) - can't write ini '%s'", saveReason, iniFilename_.c_str());
1407
			return false;
1408
		}
1409
		INFO_LOG(Log::Loader, "Config saved (%s): '%s' (%0.1f ms)", saveReason, iniFilename_.c_str(), (time_now_d() - startTime) * 1000.0);
1410

1411
		if (!bGameSpecific) //otherwise we already did this in saveGameConfig()
1412
		{
1413
			IniFile controllerIniFile;
1414
			if (!controllerIniFile.Load(controllerIniFilename_)) {
1415
				ERROR_LOG(Log::Loader, "Error saving controller config - can't read ini first '%s'", controllerIniFilename_.c_str());
1416
			}
1417
			KeyMap::SaveToIni(controllerIniFile);
1418
			if (!controllerIniFile.Save(controllerIniFilename_)) {
1419
				ERROR_LOG(Log::Loader, "Error saving config - can't write ini '%s'", controllerIniFilename_.c_str());
1420
				return false;
1421
			}
1422
			INFO_LOG(Log::Loader, "Controller config saved: %s", controllerIniFilename_.c_str());
1423
		}
1424

1425
		PostSaveCleanup(false);
1426
	} else {
1427
		INFO_LOG(Log::Loader, "Not saving config");
1428
	}
1429

1430
	return true;
1431
}
1432

1433
// A lot more cleanup tasks should be moved into here, and some of these are severely outdated.
1434
void Config::PostLoadCleanup(bool gameSpecific) {
1435
	// Override ppsspp.ini JIT value to prevent crashing
1436
	jitForcedOff = DefaultCpuCore() != (int)CPUCore::JIT && (g_Config.iCpuCore == (int)CPUCore::JIT || g_Config.iCpuCore == (int)CPUCore::JIT_IR);
1437
	if (jitForcedOff) {
1438
		g_Config.iCpuCore = (int)CPUCore::IR_INTERPRETER;
1439
	}
1440

1441
	// This caps the exponent 4 (so 16x.)
1442
	if (iAnisotropyLevel > 4) {
1443
		iAnisotropyLevel = 4;
1444
	}
1445

1446
	// Set a default MAC, and correct if it's an old format.
1447
	if (sMACAddress.length() != 17)
1448
		sMACAddress = CreateRandMAC();
1449

1450
	if (g_Config.bAutoFrameSkip && g_Config.bSkipBufferEffects) {
1451
		g_Config.bSkipBufferEffects = false;
1452
	}
1453

1454
	// Automatically silence secondary instances. Could be an option I guess, but meh.
1455
	if (PPSSPP_ID > 1) {
1456
		g_Config.iGameVolume = 0;
1457
	}
1458

1459
	// Automatically switch away from deprecated setting value.
1460
	if (iTexScalingLevel <= 0) {
1461
		iTexScalingLevel = 1;
1462
	}
1463

1464
	// Remove a legacy value.
1465
	if (g_Config.sCustomDriver == "Default") {
1466
		g_Config.sCustomDriver = "";
1467
	}
1468
}
1469

1470
void Config::PreSaveCleanup(bool gameSpecific) {
1471
	if (jitForcedOff) {
1472
		// If we forced jit off and it's still set to IR, change it back to jit.
1473
		if (g_Config.iCpuCore == (int)CPUCore::IR_INTERPRETER)
1474
			g_Config.iCpuCore = (int)CPUCore::JIT;
1475
	}
1476
}
1477

1478
void Config::PostSaveCleanup(bool gameSpecific) {
1479
	if (jitForcedOff) {
1480
		// Force JIT off again just in case Config::Save() is called without exiting PPSSPP.
1481
		if (g_Config.iCpuCore == (int)CPUCore::JIT)
1482
			g_Config.iCpuCore = (int)CPUCore::IR_INTERPRETER;
1483
	}
1484
}
1485

1486
void Config::NotifyUpdatedCpuCore() {
1487
	if (jitForcedOff && g_Config.iCpuCore == (int)CPUCore::IR_INTERPRETER) {
1488
		// No longer forced off, the user set it to IR jit.
1489
		jitForcedOff = false;
1490
	}
1491
}
1492

1493
// On iOS, the path to the app documents directory changes on each launch.
1494
// Example path:
1495
// /var/mobile/Containers/Data/Application/0E0E89DE-8D8E-485A-860C-700D8BC87B86/Documents/PSP/GAME/SuicideBarbie
1496
// The GUID part changes on each launch.
1497
bool TryUpdateSavedPath(Path *path) {
1498
#if PPSSPP_PLATFORM(IOS)
1499
	// DEBUG_LOG(Log::Loader, "Original path: %s", path->c_str());
1500
	std::string pathStr = path->ToString();
1501

1502
	const std::string_view applicationRoot = "/var/mobile/Containers/Data/Application/";
1503
	if (startsWith(pathStr, applicationRoot)) {
1504
		size_t documentsPos = pathStr.find("/Documents/");
1505
		if (documentsPos == std::string::npos) {
1506
			return false;
1507
		}
1508
		std::string memstick = g_Config.memStickDirectory.ToString();
1509
		size_t memstickDocumentsPos = memstick.find("/Documents");  // Note: No trailing slash, or we won't find it.
1510
		*path = Path(memstick.substr(0, memstickDocumentsPos) + pathStr.substr(documentsPos));
1511
		return true;
1512
	} else {
1513
		// Path can't be auto-updated.
1514
		return false;
1515
	}
1516
#else
1517
	return false;
1518
#endif
1519
}
1520

1521
void Config::SetSearchPath(const Path &searchPath) {
1522
	searchPath_ = searchPath;
1523
}
1524

1525
const Path Config::FindConfigFile(const std::string &baseFilename, bool *exists) {
1526
	// Don't search for an absolute path.
1527
	if (baseFilename.size() > 1 && baseFilename[0] == '/') {
1528
		Path path(baseFilename);
1529
		*exists = File::Exists(path);
1530
		return path;
1531
	}
1532
#ifdef _WIN32
1533
	if (baseFilename.size() > 3 && baseFilename[1] == ':' && (baseFilename[2] == '/' || baseFilename[2] == '\\')) {
1534
		Path path(baseFilename);
1535
		*exists = File::Exists(path);
1536
		return path;
1537
	}
1538
#endif
1539

1540
	Path filename = searchPath_ / baseFilename;
1541
	if (File::Exists(filename)) {
1542
		*exists = true;
1543
		return filename;
1544
	}
1545
	*exists = false;
1546
	// Make sure at least the directory it's supposed to be in exists.
1547
	Path parent = filename.NavigateUp();
1548

1549
	// We try to create the path and ignore if it fails (already exists).
1550
	if (parent != GetSysDirectory(DIRECTORY_SYSTEM)) {
1551
		File::CreateFullPath(parent);
1552
	}
1553
	return filename;
1554
}
1555

1556
void Config::RestoreDefaults(RestoreSettingsBits whatToRestore) {
1557
	if (bGameSpecific) {
1558
		// TODO: This should be possible to do in a cleaner way.
1559
		deleteGameConfig(gameId_);
1560
		createGameConfig(gameId_);
1561
		Load();
1562
	} else {
1563
		if (whatToRestore & RestoreSettingsBits::SETTINGS) {
1564
			IterateSettings([](const ConfigSetting &setting) {
1565
				setting.RestoreToDefault();
1566
			});
1567
		}
1568

1569
		if (whatToRestore & RestoreSettingsBits::CONTROLS) {
1570
			KeyMap::RestoreDefault();
1571
		}
1572

1573
		if (whatToRestore & RestoreSettingsBits::RECENT) {
1574
			g_recentFiles.Clear();
1575
			currentDirectory = defaultCurrentDirectory;
1576
		}
1577
	}
1578
}
1579

1580
bool Config::hasGameConfig(const std::string &pGameId) {
1581
	bool exists = false;
1582
	Path fullIniFilePath = getGameConfigFile(pGameId, &exists);
1583
	return exists;
1584
}
1585

1586
void Config::changeGameSpecific(const std::string &pGameId, const std::string &title) {
1587
	if (!reload_)
1588
		Save("changeGameSpecific");
1589
	gameId_ = pGameId;
1590
	gameIdTitle_ = title;
1591
	bGameSpecific = !pGameId.empty();
1592
}
1593

1594
bool Config::createGameConfig(const std::string &pGameId) {
1595
	bool exists;
1596
	Path fullIniFilePath = getGameConfigFile(pGameId, &exists);
1597

1598
	if (exists) {
1599
		INFO_LOG(Log::System, "Game config already exists");
1600
		return false;
1601
	}
1602

1603
	File::CreateEmptyFile(fullIniFilePath);
1604
	return true;
1605
}
1606

1607
bool Config::deleteGameConfig(const std::string& pGameId) {
1608
	bool exists;
1609
	Path fullIniFilePath = Path(getGameConfigFile(pGameId, &exists));
1610

1611
	if (exists) {
1612
		if (System_GetPropertyBool(SYSPROP_HAS_TRASH_BIN)) {
1613
			System_MoveToTrash(fullIniFilePath);
1614
		} else {
1615
			File::Delete(fullIniFilePath);
1616
		}
1617
	}
1618
	return true;
1619
}
1620

1621
Path Config::getGameConfigFile(const std::string &pGameId, bool *exists) {
1622
	const char *ppssppIniFilename = IsVREnabled() ? "_ppssppvr.ini" : "_ppsspp.ini";
1623
	std::string iniFileName = pGameId + ppssppIniFilename;
1624
	Path iniFileNameFull = FindConfigFile(iniFileName, exists);
1625

1626
	return iniFileNameFull;
1627
}
1628

1629
bool Config::saveGameConfig(const std::string &pGameId, const std::string &titleForComment) {
1630
	if (pGameId.empty()) {
1631
		return false;
1632
	}
1633

1634
	bool exists;
1635
	Path fullIniFilePath = getGameConfigFile(pGameId, &exists);
1636

1637
	IniFile iniFile;
1638

1639
	Section *top = iniFile.GetOrCreateSection("");
1640
	top->AddComment(StringFromFormat("Game config for %s - %s", pGameId.c_str(), titleForComment.c_str()));
1641

1642
	PreSaveCleanup(true);
1643

1644
	IterateSettings(iniFile, [](Section *section, const ConfigSetting &setting) {
1645
		if (setting.PerGame()) {
1646
			setting.Set(section);
1647
		}
1648
	});
1649

1650
	Section *postShaderSetting = iniFile.GetOrCreateSection("PostShaderSetting");
1651
	postShaderSetting->Clear();
1652
	for (const auto &[k, v] : mPostShaderSetting) {
1653
		postShaderSetting->Set(k, v);
1654
	}
1655

1656
	Section *postShaderChain = iniFile.GetOrCreateSection("PostShaderList");
1657
	postShaderChain->Clear();
1658
	for (size_t i = 0; i < vPostShaderNames.size(); ++i) {
1659
		char keyName[64];
1660
		snprintf(keyName, sizeof(keyName), "PostShader%d", (int)i+1);
1661
		postShaderChain->Set(keyName, vPostShaderNames[i]);
1662
	}
1663

1664
	KeyMap::SaveToIni(iniFile);
1665
	iniFile.Save(fullIniFilePath);
1666

1667
	PostSaveCleanup(true);
1668
	return true;
1669
}
1670

1671
bool Config::loadGameConfig(const std::string &pGameId, const std::string &title) {
1672
	bool exists;
1673
	Path iniFileNameFull = getGameConfigFile(pGameId, &exists);
1674
	if (!exists) {
1675
		DEBUG_LOG(Log::Loader, "No game-specific settings found in %s. Using global defaults.", iniFileNameFull.c_str());
1676
		return false;
1677
	}
1678

1679
	changeGameSpecific(pGameId, title);
1680
	IniFile iniFile;
1681
	iniFile.Load(iniFileNameFull);
1682

1683
	auto postShaderSetting = iniFile.GetOrCreateSection("PostShaderSetting")->ToMap();
1684
	mPostShaderSetting.clear();
1685
	for (const auto &[k, v] : postShaderSetting) {
1686
		float value = 0.0f;
1687
		if (sscanf(v.c_str(), "%f", &value)) {
1688
			mPostShaderSetting[k] = value;
1689
		} else {
1690
			WARN_LOG(Log::Loader, "Invalid float value string for param %s: '%s'", k.c_str(), v.c_str());
1691
		}
1692
	}
1693

1694
	auto postShaderChain = iniFile.GetOrCreateSection("PostShaderList")->ToMap();
1695
	vPostShaderNames.clear();
1696
	for (const auto &[_, v] : postShaderChain) {
1697
		if (v != "Off")
1698
			vPostShaderNames.push_back(v);
1699
	}
1700

1701
	IterateSettings(iniFile, [](Section *section, const ConfigSetting &setting) {
1702
		if (setting.PerGame()) {
1703
			setting.Get(section);
1704
		}
1705
	});
1706

1707
	KeyMap::LoadFromIni(iniFile);
1708

1709
	if (!appendedConfigFileName_.ToString().empty() &&
1710
		std::find(appendedConfigUpdatedGames_.begin(), appendedConfigUpdatedGames_.end(), pGameId) == appendedConfigUpdatedGames_.end()) {
1711

1712
		LoadAppendedConfig();
1713
		appendedConfigUpdatedGames_.push_back(pGameId);
1714
	}
1715

1716
	PostLoadCleanup(true);
1717
	return true;
1718
}
1719

1720
void Config::unloadGameConfig() {
1721
	if (bGameSpecific) {
1722
		changeGameSpecific();
1723

1724
		IniFile iniFile;
1725
		iniFile.Load(iniFilename_);
1726

1727
		// Reload game specific settings back to standard.
1728
		IterateSettings(iniFile, [](Section *section, const ConfigSetting &setting) {
1729
			if (setting.PerGame()) {
1730
				setting.Get(section);
1731
			}
1732
		});
1733

1734
		auto postShaderSetting = iniFile.GetOrCreateSection("PostShaderSetting")->ToMap();
1735
		mPostShaderSetting.clear();
1736
		for (const auto &[k, v] : postShaderSetting) {
1737
			mPostShaderSetting[k] = std::stof(v);
1738
		}
1739

1740
		auto postShaderChain = iniFile.GetOrCreateSection("PostShaderList")->ToMap();
1741
		vPostShaderNames.clear();
1742
		for (const auto &[k, v] : postShaderChain) {
1743
			if (v != "Off")
1744
				vPostShaderNames.push_back(v);
1745
		}
1746

1747
		LoadStandardControllerIni();
1748
		PostLoadCleanup(true);
1749
	}
1750
}
1751

1752
void Config::LoadStandardControllerIni() {
1753
	IniFile controllerIniFile;
1754
	if (!controllerIniFile.Load(controllerIniFilename_)) {
1755
		ERROR_LOG(Log::Loader, "Failed to read %s. Setting controller config to default.", controllerIniFilename_.c_str());
1756
		KeyMap::RestoreDefault();
1757
	} else {
1758
		// Continue anyway to initialize the config. It will just restore the defaults.
1759
		KeyMap::LoadFromIni(controllerIniFile);
1760
	}
1761
}
1762

1763
void Config::ResetControlLayout() {
1764
	auto reset = [](ConfigTouchPos &pos) {
1765
		pos.x = defaultTouchPosShow.x;
1766
		pos.y = defaultTouchPosShow.y;
1767
		pos.scale = defaultTouchPosShow.scale;
1768
	};
1769
	reset(g_Config.touchActionButtonCenter);
1770
	g_Config.fActionButtonSpacing = 1.0f;
1771
	reset(g_Config.touchDpad);
1772
	g_Config.fDpadSpacing = 1.0f;
1773
	reset(g_Config.touchStartKey);
1774
	reset(g_Config.touchSelectKey);
1775
	reset(g_Config.touchFastForwardKey);
1776
	reset(g_Config.touchLKey);
1777
	reset(g_Config.touchRKey);
1778
	reset(g_Config.touchAnalogStick);
1779
	reset(g_Config.touchRightAnalogStick);
1780
	for (int i = 0; i < CUSTOM_BUTTON_COUNT; i++) {
1781
		reset(g_Config.touchCustom[i]);
1782
	}
1783
	g_Config.fLeftStickHeadScale = 1.0f;
1784
	g_Config.fRightStickHeadScale = 1.0f;
1785
}
1786

1787
void Config::GetReportingInfo(UrlEncoder &data) const {
1788
	for (size_t i = 0; i < numSections; ++i) {
1789
		const std::string prefix = std::string("config.") + sections[i].section;
1790
		for (size_t j = 0; j < sections[i].settingsCount; j++) {
1791
			sections[i].settings[j].ReportSetting(data, prefix);
1792
		}
1793
	}
1794
}
1795

1796
bool Config::IsPortrait() const {
1797
	return (iInternalScreenRotation == ROTATION_LOCKED_VERTICAL || iInternalScreenRotation == ROTATION_LOCKED_VERTICAL180) && !bSkipBufferEffects;
1798
}
1799

1800
int Config::GetPSPLanguage() {
1801
	if (g_Config.iLanguage == -1) {
1802
		const auto &langValuesMapping = GetLangValuesMapping();
1803
		auto iter = langValuesMapping.find(g_Config.sLanguageIni);
1804
		if (iter != langValuesMapping.end()) {
1805
			return iter->second.second;
1806
		} else {
1807
			// Fallback to English
1808
			return PSP_SYSTEMPARAM_LANGUAGE_ENGLISH;
1809
		}
1810
	} else {
1811
		return g_Config.iLanguage;
1812
	}
1813
}
1814

1815
void PlayTimeTracker::Start(const std::string &gameId) {
1816
	if (gameId.empty()) {
1817
		return;
1818
	}
1819
	VERBOSE_LOG(Log::System, "GameTimeTracker::Start(%s)", gameId.c_str());
1820

1821
	auto iter = tracker_.find(std::string(gameId));
1822
	if (iter != tracker_.end()) {
1823
		if (iter->second.startTime == 0.0) {
1824
			iter->second.lastTimePlayed = time_now_unix_utc();
1825
			iter->second.startTime = time_now_d();
1826
		}
1827
		return;
1828
	}
1829

1830
	PlayTime playTime;
1831
	playTime.lastTimePlayed = time_now_unix_utc();
1832
	playTime.totalTimePlayed = 0.0;
1833
	playTime.startTime = time_now_d();
1834
	tracker_[gameId] = playTime;
1835
}
1836

1837
void PlayTimeTracker::Stop(const std::string &gameId) {
1838
	if (gameId.empty()) {
1839
		return;
1840
	}
1841

1842
	VERBOSE_LOG(Log::System, "GameTimeTracker::Stop(%s)", gameId.c_str());
1843

1844
	auto iter = tracker_.find(std::string(gameId));
1845
	if (iter != tracker_.end()) {
1846
		if (iter->second.startTime != 0.0) {
1847
			iter->second.totalTimePlayed += time_now_d() - iter->second.startTime;
1848
			iter->second.startTime = 0.0;
1849
		}
1850
		iter->second.lastTimePlayed = time_now_unix_utc();
1851
		return;
1852
	}
1853

1854
	// Shouldn't happen, ignore this case.
1855
	WARN_LOG(Log::System, "GameTimeTracker::Stop called without corresponding GameTimeTracker::Start");
1856
}
1857

1858
void PlayTimeTracker::Load(const Section *section) {
1859
	tracker_.clear();
1860

1861
	auto map = section->ToMap();
1862

1863
	for (const auto &iter : map) {
1864
		const std::string &value = iter.second;
1865
		// Parse the string.
1866
		PlayTime gameTime{};
1867
		if (2 == sscanf(value.c_str(), "%d,%llu", &gameTime.totalTimePlayed, (long long *)&gameTime.lastTimePlayed)) {
1868
			tracker_[iter.first] = gameTime;
1869
		}
1870
	}
1871
}
1872

1873
void PlayTimeTracker::Save(Section *section) {
1874
	for (auto &iter : tracker_) {
1875
		std::string formatted = StringFromFormat("%d,%llu", iter.second.totalTimePlayed, iter.second.lastTimePlayed);
1876
		section->Set(iter.first, formatted);
1877
	}
1878
}
1879

1880
bool PlayTimeTracker::GetPlayedTimeString(const std::string &gameId, std::string *str) const {
1881
	auto ga = GetI18NCategory(I18NCat::GAME);
1882

1883
	auto iter = tracker_.find(gameId);
1884
	if (iter == tracker_.end()) {
1885
		return false;
1886
	}
1887

1888
	int totalSeconds = iter->second.totalTimePlayed;
1889
	int seconds = totalSeconds % 60;
1890
	totalSeconds /= 60;
1891
	int minutes = totalSeconds % 60;
1892
	totalSeconds /= 60;
1893
	int hours = totalSeconds;
1894

1895
	*str = ApplySafeSubstitutions(ga->T("Time Played: %1h %2m %3s"), hours, minutes, seconds);
1896
	return true;
1897
}
1898

1899
// This matches exactly the old shift-based curve.
1900
float Volume10ToMultiplier(int volume) {
1901
	// Allow muting entirely.
1902
	if (volume <= 0) {
1903
		return 0.0f;
1904
	}
1905
	return powf(2.0f, (float)(volume - 10));
1906
}
1907

1908
// NOTE: This is used for new volume parameters.
1909
// It uses a more intuitive-feeling curve.
1910
float Volume100ToMultiplier(int volume) {
1911
	// Switch to linear above the 1.0f point.
1912
	if (volume > 100) {
1913
		return volume / 100.0f;
1914
	}
1915
	return powf(volume * 0.01f, 1.75f);
1916
}
1917

1918
// Used for migration from the old settings.
1919
int MultiplierToVolume100(float multiplier) {
1920
	// Switch to linear above the 1.0f point.
1921
	if (multiplier > 1.0f) {
1922
		return multiplier * 100;
1923
	}
1924
	return (int)(powf(multiplier, 1.0f / 1.75f) * 100.f + 0.5f);
1925
}
1926

1927
float UIScaleFactorToMultiplier(int factor) {
1928
	return powf(2.0f, (float)factor / 8.0f);
1929
}
1930

1931
Product

Resources

Company
