modernize #1

src/ios/Eden/AppUI.swift

@@ -80,13 +80,9 @@ public struct AppUI {
     public func gyroMoved(x: Float, y: Float, z: Float, accelX: Float, accelY: Float, accelZ: Float, controllerId: Int32, deltaTimestamp: Int32) {
         // Calling the Objective-C function with both gyroscope and accelerometer data
         appUIObjC.virtualControllerGyro(controllerId,
-                                          deltaTimestamp: deltaTimestamp,
-                                          gyroX: x,
-                                          gyroY: y,
-                                          gyroZ: z,
-                                          accelX: accelX,
-                                          accelY: accelY,
-                                          accelZ: accelZ)
+            deltaTimestamp: deltaTimestamp,
+            gyroX: x, gyroY: y, gyroZ: z,
+            accelX: accelX, accelY: accelY, accelZ: accelZ)
     }
 
 

src/ios/Eden/Wrapper/AppUIGameInformation/AppUIGameInformation.mm

@@ -26,7 +26,7 @@ struct GameMetadata {
 };
 
 
-class SdlConfig final : public YuzuConfig {
+class SdlConfig final : public Config {
 public:
     explicit SdlConfig(std::optional<std::string> config_path);
     ~SdlConfig() override;
@@ -59,12 +59,12 @@ protected:
     void SaveUILayoutValues() override {}
     void SaveMultiplayerValues() override {}
 
-    std::vector<YuzuSettings::BasicSetting*>& FindRelevantList(YuzuSettings::Category category) override;
+    std::vector<Settings::BasicSetting*>& FindRelevantList(Settings::Category category) override;
 
 public:
-    static const std::array<int, YuzuSettings::NativeButton::NumButtons> default_buttons;
-    static const std::array<int, YuzuSettings::NativeMotion::NumMotions> default_motions;
-    static const std::array<std::array<int, 4>, YuzuSettings::NativeAnalog::NumAnalogs> default_analogs;
+    static const std::array<int, Settings::NativeButton::NumButtons> default_buttons;
+    static const std::array<int, Settings::NativeMotion::NumMotions> default_motions;
+    static const std::array<std::array<int, 4>, Settings::NativeAnalog::NumAnalogs> default_analogs;
     static const std::array<int, 2> default_stick_mod;
     static const std::array<int, 2> default_ringcon_analogs;
 };
@@ -76,18 +76,18 @@ public:
 #include "common/logging/log.h"
 #include "input_common/main.h"
 
-const std::array<int, YuzuSettings::NativeButton::NumButtons> SdlConfig::default_buttons = {
+const std::array<int, Settings::NativeButton::NumButtons> SdlConfig::default_buttons = {
     SDL_SCANCODE_A, SDL_SCANCODE_S, SDL_SCANCODE_Z, SDL_SCANCODE_X, SDL_SCANCODE_T,
     SDL_SCANCODE_G, SDL_SCANCODE_F, SDL_SCANCODE_H, SDL_SCANCODE_Q, SDL_SCANCODE_W,
     SDL_SCANCODE_M, SDL_SCANCODE_N, SDL_SCANCODE_1, SDL_SCANCODE_2, SDL_SCANCODE_B,
 };
 
-const std::array<int, YuzuSettings::NativeMotion::NumMotions> SdlConfig::default_motions = {
+const std::array<int, Settings::NativeMotion::NumMotions> SdlConfig::default_motions = {
     SDL_SCANCODE_7,
     SDL_SCANCODE_8,
 };
 
-const std::array<std::array<int, 4>, YuzuSettings::NativeAnalog::NumAnalogs> SdlConfig::default_analogs{
+const std::array<std::array<int, 4>, Settings::NativeAnalog::NumAnalogs> SdlConfig::default_analogs{
     {
         {
             SDL_SCANCODE_UP,
@@ -141,10 +141,10 @@ void SdlConfig::ReadSdlValues() {
 }
 
 void SdlConfig::ReadSdlControlValues() {
-    BeginGroup(YuzuSettings::TranslateCategory(YuzuSettings::Category::Controls));
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Controls));
 
-    YuzuSettings::values.players.SetGlobal(!IsCustomConfig());
-    for (std::size_t p = 0; p < YuzuSettings::values.players.GetValue().size(); ++p) {
+    Settings::values.players.SetGlobal(!IsCustomConfig());
+    for (std::size_t p = 0; p < Settings::values.players.GetValue().size(); ++p) {
         ReadSdlPlayerValues(p);
     }
     if (IsCustomConfig()) {
@@ -163,48 +163,48 @@ void SdlConfig::ReadSdlPlayerValues(const std::size_t player_index) {
         player_prefix.append("player_").append(ToString(player_index)).append("_");
     }
 
-    auto& player = YuzuSettings::values.players.GetValue()[player_index];
+    auto& player = Settings::values.players.GetValue()[player_index];
     if (IsCustomConfig()) {
         const auto profile_name =
             ReadStringSetting(std::string(player_prefix).append("profile_name"));
         if (profile_name.empty()) {
             // Use the global input config
-            player = YuzuSettings::values.players.GetValue(true)[player_index];
+            player = Settings::values.players.GetValue(true)[player_index];
             player.profile_name = "";
             return;
         }
     }
 
-    for (int i = 0; i < YuzuSettings::NativeButton::NumButtons; ++i) {
+    for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
         const std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
         auto& player_buttons = player.buttons[i];
 
         player_buttons = ReadStringSetting(
-            std::string(player_prefix).append(YuzuSettings::NativeButton::mapping[i]), default_param);
+            std::string(player_prefix).append(Settings::NativeButton::mapping[i]), default_param);
         if (player_buttons.empty()) {
             player_buttons = default_param;
         }
     }
 
-    for (int i = 0; i < YuzuSettings::NativeAnalog::NumAnalogs; ++i) {
+    for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
         const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
             default_analogs[i][0], default_analogs[i][1], default_analogs[i][2],
             default_analogs[i][3], default_stick_mod[i], 0.5f);
         auto& player_analogs = player.analogs[i];
 
         player_analogs = ReadStringSetting(
-            std::string(player_prefix).append(YuzuSettings::NativeAnalog::mapping[i]), default_param);
+            std::string(player_prefix).append(Settings::NativeAnalog::mapping[i]), default_param);
         if (player_analogs.empty()) {
             player_analogs = default_param;
         }
     }
 
-    for (int i = 0; i < YuzuSettings::NativeMotion::NumMotions; ++i) {
+    for (int i = 0; i < Settings::NativeMotion::NumMotions; ++i) {
         const std::string default_param = InputCommon::GenerateKeyboardParam(default_motions[i]);
         auto& player_motions = player.motions[i];
 
         player_motions = ReadStringSetting(
-            std::string(player_prefix).append(YuzuSettings::NativeMotion::mapping[i]), default_param);
+            std::string(player_prefix).append(Settings::NativeMotion::mapping[i]), default_param);
         if (player_motions.empty()) {
             player_motions = default_param;
         }
@@ -212,22 +212,22 @@ void SdlConfig::ReadSdlPlayerValues(const std::size_t player_index) {
 }
 
 void SdlConfig::ReadDebugControlValues() {
-    for (int i = 0; i < YuzuSettings::NativeButton::NumButtons; ++i) {
+    for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
         const std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
-        auto& debug_pad_buttons = YuzuSettings::values.debug_pad_buttons[i];
+        auto& debug_pad_buttons = Settings::values.debug_pad_buttons[i];
         debug_pad_buttons = ReadStringSetting(
-            std::string("debug_pad_").append(YuzuSettings::NativeButton::mapping[i]), default_param);
+            std::string("debug_pad_").append(Settings::NativeButton::mapping[i]), default_param);
         if (debug_pad_buttons.empty()) {
             debug_pad_buttons = default_param;
         }
     }
-    for (int i = 0; i < YuzuSettings::NativeAnalog::NumAnalogs; ++i) {
+    for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
         const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
             default_analogs[i][0], default_analogs[i][1], default_analogs[i][2],
             default_analogs[i][3], default_stick_mod[i], 0.5f);
-        auto& debug_pad_analogs = YuzuSettings::values.debug_pad_analogs[i];
+        auto& debug_pad_analogs = Settings::values.debug_pad_analogs[i];
         debug_pad_analogs = ReadStringSetting(
-            std::string("debug_pad_").append(YuzuSettings::NativeAnalog::mapping[i]), default_param);
+            std::string("debug_pad_").append(Settings::NativeAnalog::mapping[i]), default_param);
         if (debug_pad_analogs.empty()) {
             debug_pad_analogs = default_param;
         }
@@ -237,7 +237,7 @@ void SdlConfig::ReadDebugControlValues() {
 void SdlConfig::ReadHidbusValues() {
     const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
         0, 0, default_ringcon_analogs[0], default_ringcon_analogs[1], 0, 0.05f);
-    auto& ringcon_analogs = YuzuSettings::values.ringcon_analogs;
+    auto& ringcon_analogs = Settings::values.ringcon_analogs;
 
     ringcon_analogs = ReadStringSetting(std::string("ring_controller"), default_param);
     if (ringcon_analogs.empty()) {
@@ -253,10 +253,10 @@ void SdlConfig::SaveSdlValues() {
 }
 
 void SdlConfig::SaveSdlControlValues() {
-    BeginGroup(YuzuSettings::TranslateCategory(YuzuSettings::Category::Controls));
+    BeginGroup(Settings::TranslateCategory(Settings::Category::Controls));
 
-    YuzuSettings::values.players.SetGlobal(!IsCustomConfig());
-    for (std::size_t p = 0; p < YuzuSettings::values.players.GetValue().size(); ++p) {
+    Settings::values.players.SetGlobal(!IsCustomConfig());
+    for (std::size_t p = 0; p < Settings::values.players.GetValue().size(); ++p) {
         SaveSdlPlayerValues(p);
     }
     if (IsCustomConfig()) {
@@ -275,44 +275,44 @@ void SdlConfig::SaveSdlPlayerValues(const std::size_t player_index) {
         player_prefix = std::string("player_").append(ToString(player_index)).append("_");
     }
 
-    const auto& player = YuzuSettings::values.players.GetValue()[player_index];
+    const auto& player = Settings::values.players.GetValue()[player_index];
     if (IsCustomConfig() && player.profile_name.empty()) {
         // No custom profile selected
         return;
     }
 
-    for (int i = 0; i < YuzuSettings::NativeButton::NumButtons; ++i) {
+    for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
         const std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
-        WriteStringSetting(std::string(player_prefix).append(YuzuSettings::NativeButton::mapping[i]),
+        WriteStringSetting(std::string(player_prefix).append(Settings::NativeButton::mapping[i]),
                            player.buttons[i], std::make_optional(default_param));
     }
-    for (int i = 0; i < YuzuSettings::NativeAnalog::NumAnalogs; ++i) {
+    for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
         const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
             default_analogs[i][0], default_analogs[i][1], default_analogs[i][2],
             default_analogs[i][3], default_stick_mod[i], 0.5f);
-        WriteStringSetting(std::string(player_prefix).append(YuzuSettings::NativeAnalog::mapping[i]),
+        WriteStringSetting(std::string(player_prefix).append(Settings::NativeAnalog::mapping[i]),
                            player.analogs[i], std::make_optional(default_param));
     }
-    for (int i = 0; i < YuzuSettings::NativeMotion::NumMotions; ++i) {
+    for (int i = 0; i < Settings::NativeMotion::NumMotions; ++i) {
         const std::string default_param = InputCommon::GenerateKeyboardParam(default_motions[i]);
-        WriteStringSetting(std::string(player_prefix).append(YuzuSettings::NativeMotion::mapping[i]),
+        WriteStringSetting(std::string(player_prefix).append(Settings::NativeMotion::mapping[i]),
                            player.motions[i], std::make_optional(default_param));
     }
 }
 
 void SdlConfig::SaveDebugControlValues() {
-    for (int i = 0; i < YuzuSettings::NativeButton::NumButtons; ++i) {
+    for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
         const std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
-        WriteStringSetting(std::string("debug_pad_").append(YuzuSettings::NativeButton::mapping[i]),
-                           YuzuSettings::values.debug_pad_buttons[i],
+        WriteStringSetting(std::string("debug_pad_").append(Settings::NativeButton::mapping[i]),
+                           Settings::values.debug_pad_buttons[i],
                            std::make_optional(default_param));
     }
-    for (int i = 0; i < YuzuSettings::NativeAnalog::NumAnalogs; ++i) {
+    for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
         const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
             default_analogs[i][0], default_analogs[i][1], default_analogs[i][2],
             default_analogs[i][3], default_stick_mod[i], 0.5f);
-        WriteStringSetting(std::string("debug_pad_").append(YuzuSettings::NativeAnalog::mapping[i]),
-                           YuzuSettings::values.debug_pad_analogs[i],
+        WriteStringSetting(std::string("debug_pad_").append(Settings::NativeAnalog::mapping[i]),
+                           Settings::values.debug_pad_analogs[i],
                            std::make_optional(default_param));
     }
 }
@@ -320,12 +320,12 @@ void SdlConfig::SaveDebugControlValues() {
 void SdlConfig::SaveHidbusValues() {
     const std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
         0, 0, default_ringcon_analogs[0], default_ringcon_analogs[1], 0, 0.05f);
-    WriteStringSetting(std::string("ring_controller"), YuzuSettings::values.ringcon_analogs,
+    WriteStringSetting(std::string("ring_controller"), Settings::values.ringcon_analogs,
                        std::make_optional(default_param));
 }
 
-std::vector<YuzuSettings::BasicSetting*>& SdlConfig::FindRelevantList(YuzuSettings::Category category) {
-    return YuzuSettings::values.linkage.by_category[category];
+std::vector<Settings::BasicSetting*>& SdlConfig::FindRelevantList(Settings::Category category) {
+    return Settings::values.linkage.by_category[category];
 }
 
 

src/ios/Eden/Wrapper/Config/Config.h

@@ -1,568 +1,19 @@
-//
-//  Config.h
-//  AppUI
-//
-//  Created by Jarrod Norwell on 13/3/2024.
-//
-
-// SPDX-FileCopyrightText: 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
 
 #pragma once
 
-namespace DefaultINI {
-
-const char* android_config_file = R"(
-
-[ControlsP0]
-# The input devices and parameters for each Switch native input
-# The config section determines the player number where the config will be applied on. For example "ControlsP0", "ControlsP1", ...
-# It should be in the format of "engine:[engine_name],[param1]:[value1],[param2]:[value2]..."
-# Escape characters $0 (for ':'), $1 (for ',') and $2 (for '$') can be used in values
-
-# Indicates if this player should be connected at boot
-connected=
-
-# for button input, the following devices are available:
-#  - "keyboard" (default) for keyboard input. Required parameters:
-#      - "code": the code of the key to bind
-#  - "sdl" for joystick input using SDL. Required parameters:
-#      - "guid": SDL identification GUID of the joystick
-#      - "port": the index of the joystick to bind
-#      - "button"(optional): the index of the button to bind
-#      - "hat"(optional): the index of the hat to bind as direction buttons
-#      - "axis"(optional): the index of the axis to bind
-#      - "direction"(only used for hat): the direction name of the hat to bind. Can be "up", "down", "left" or "right"
-#      - "threshold"(only used for axis): a float value in (-1.0, 1.0) which the button is
-#          triggered if the axis value crosses
-#      - "direction"(only used for axis): "+" means the button is triggered when the axis value
-#          is greater than the threshold; "-" means the button is triggered when the axis value
-#          is smaller than the threshold
-button_a=
-button_b=
-button_x=
-button_y=
-button_lstick=
-button_rstick=
-button_l=
-button_r=
-button_zl=
-button_zr=
-button_plus=
-button_minus=
-button_dleft=
-button_dup=
-button_dright=
-button_ddown=
-button_lstick_left=
-button_lstick_up=
-button_lstick_right=
-button_lstick_down=
-button_sl=
-button_sr=
-button_home=
-button_screenshot=
-
-# for analog input, the following devices are available:
-#  - "analog_from_button" (default) for emulating analog input from direction buttons. Required parameters:
-#      - "up", "down", "left", "right": sub-devices for each direction.
-#          Should be in the format as a button input devices using escape characters, for example, "engine$0keyboard$1code$00"
-#      - "modifier": sub-devices as a modifier.
-#      - "modifier_scale": a float number representing the applied modifier scale to the analog input.
-#          Must be in range of 0.0-1.0. Defaults to 0.5
-#  - "sdl" for joystick input using SDL. Required parameters:
-#      - "guid": SDL identification GUID of the joystick
-#      - "port": the index of the joystick to bind
-#      - "axis_x": the index of the axis to bind as x-axis (default to 0)
-#      - "axis_y": the index of the axis to bind as y-axis (default to 1)
-lstick=
-rstick=
-
-# for motion input, the following devices are available:
-#  - "keyboard" (default) for emulating random motion input from buttons. Required parameters:
-#      - "code": the code of the key to bind
-#  - "sdl" for motion input using SDL. Required parameters:
-#      - "guid": SDL identification GUID of the joystick
-#      - "port": the index of the joystick to bind
-#      - "motion": the index of the motion sensor to bind
-#  - "cemuhookudp" for motion input using Cemu Hook protocol. Required parameters:
-#      - "guid": the IP address of the cemu hook server encoded to a hex string. for example 192.168.0.1 = "c0a80001"
-#      - "port": the port of the cemu hook server
-#      - "pad": the index of the joystick
-#      - "motion": the index of the motion sensor of the joystick to bind
-motionleft=
-motionright=
-
-[ControlsGeneral]
-# To use the debug_pad, prepend debug_pad_ before each button setting above.
-# i.e. debug_pad_button_a=
-
-# Enable debug pad inputs to the guest
-# 0 (default): Disabled, 1: Enabled
-debug_pad_enabled =
-
-# Whether to enable or disable vibration
-# 0: Disabled, 1 (default): Enabled
-vibration_enabled =
-
-# Whether to enable or disable accurate vibrations
-# 0 (default): Disabled, 1: Enabled
-enable_accurate_vibrations =
-
-# Enables controller motion inputs
-# 0: Disabled, 1 (default): Enabled
-motion_enabled =
-
-# Defines the udp device's touch screen coordinate system for cemuhookudp devices
-#  - "min_x", "min_y", "max_x", "max_y"
-touch_device=
-
-# for mapping buttons to touch inputs.
-#touch_from_button_map=1
-#touch_from_button_maps_0_name=default
-#touch_from_button_maps_0_count=2
-#touch_from_button_maps_0_bind_0=foo
-#touch_from_button_maps_0_bind_1=bar
-# etc.
-
-# List of Cemuhook UDP servers, delimited by ','.
-# Default: 127.0.0.1:26760
-# Example: 127.0.0.1:26760,123.4.5.67:26761
-udp_input_servers =
-
-# Enable controlling an axis via a mouse input.
-# 0 (default): Off, 1: On
-mouse_panning =
-
-# Set mouse sensitivity.
-# Default: 1.0
-mouse_panning_sensitivity =
-
-# Emulate an analog control stick from keyboard inputs.
-# 0 (default): Disabled, 1: Enabled
-emulate_analog_keyboard =
-
-# Enable mouse inputs to the guest
-# 0 (default): Disabled, 1: Enabled
-mouse_enabled =
-
-# Enable keyboard inputs to the guest
-# 0 (default): Disabled, 1: Enabled
-keyboard_enabled =
-
-[Core]
-# Whether to use multi-core for CPU emulation
-# 0: Disabled, 1 (default): Enabled
-use_multi_core =
-
-# Enable unsafe extended guest system memory layout (8GB DRAM)
-# 0 (default): Disabled, 1: Enabled
-use_unsafe_extended_memory_layout =
-
-[Cpu]
-# Adjusts various optimizations.
-# Auto-select mode enables choice unsafe optimizations.
-# Accurate enables only safe optimizations.
-# Unsafe allows any unsafe optimizations.
-# 0 (default): Auto-select, 1: Accurate, 2: Enable unsafe optimizations
-cpu_accuracy =
-
-# Allow disabling safe optimizations.
-# 0 (default): Disabled, 1: Enabled
-cpu_debug_mode =
-
-# Enable inline page tables optimization (faster guest memory access)
-# 0: Disabled, 1 (default): Enabled
-cpuopt_page_tables =
-
-# Enable block linking CPU optimization (reduce block dispatcher use during predictable jumps)
-# 0: Disabled, 1 (default): Enabled
-cpuopt_block_linking =
-
-# Enable return stack buffer CPU optimization (reduce block dispatcher use during predictable returns)
-# 0: Disabled, 1 (default): Enabled
-cpuopt_return_stack_buffer =
-
-# Enable fast dispatcher CPU optimization (use a two-tiered dispatcher architecture)
-# 0: Disabled, 1 (default): Enabled
-cpuopt_fast_dispatcher =
-
-# Enable context elimination CPU Optimization (reduce host memory use for guest context)
-# 0: Disabled, 1 (default): Enabled
-cpuopt_context_elimination =
-
-# Enable constant propagation CPU optimization (basic IR optimization)
-# 0: Disabled, 1 (default): Enabled
-cpuopt_const_prop =
-
-# Enable miscellaneous CPU optimizations (basic IR optimization)
-# 0: Disabled, 1 (default): Enabled
-cpuopt_misc_ir =
-
-# Enable reduction of memory misalignment checks (reduce memory fallbacks for misaligned access)
-# 0: Disabled, 1 (default): Enabled
-cpuopt_reduce_misalign_checks =
-
-# Enable Host MMU Emulation (faster guest memory access)
-# 0: Disabled, 1 (default): Enabled
-cpuopt_fastmem =
-
-# Enable Host MMU Emulation for exclusive memory instructions (faster guest memory access)
-# 0: Disabled, 1 (default): Enabled
-cpuopt_fastmem_exclusives =
-
-# Enable fallback on failure of fastmem of exclusive memory instructions (faster guest memory access)
-# 0: Disabled, 1 (default): Enabled
-cpuopt_recompile_exclusives =
-
-# Enable optimization to ignore invalid memory accesses (faster guest memory access)
-# 0: Disabled, 1 (default): Enabled
-cpuopt_ignore_memory_aborts =
-
-# Enable unfuse FMA (improve performance on CPUs without FMA)
-# Only enabled if cpu_accuracy is set to Unsafe. Automatically chosen with cpu_accuracy = Auto-select.
-# 0: Disabled, 1 (default): Enabled
-cpuopt_unsafe_unfuse_fma =
-
-# Enable faster FRSQRTE and FRECPE
-# Only enabled if cpu_accuracy is set to Unsafe.
-# 0: Disabled, 1 (default): Enabled
-cpuopt_unsafe_reduce_fp_error =
-
-# Enable faster ASIMD instructions (32 bits only)
-# Only enabled if cpu_accuracy is set to Unsafe. Automatically chosen with cpu_accuracy = Auto-select.
-# 0: Disabled, 1 (default): Enabled
-cpuopt_unsafe_ignore_standard_fpcr =
-
-# Enable inaccurate NaN handling
-# Only enabled if cpu_accuracy is set to Unsafe. Automatically chosen with cpu_accuracy = Auto-select.
-# 0: Disabled, 1 (default): Enabled
-cpuopt_unsafe_inaccurate_nan =
-
-# Disable address space checks (64 bits only)
-# Only enabled if cpu_accuracy is set to Unsafe. Automatically chosen with cpu_accuracy = Auto-select.
-# 0: Disabled, 1 (default): Enabled
-cpuopt_unsafe_fastmem_check =
-
-# Enable faster exclusive instructions
-# Only enabled if cpu_accuracy is set to Unsafe. Automatically chosen with cpu_accuracy = Auto-select.
-# 0: Disabled, 1 (default): Enabled
-cpuopt_unsafe_ignore_global_monitor =
-
-[Renderer]
-# Which backend API to use.
-# 0: OpenGL (unsupported), 1 (default): Vulkan, 2: Null
-backend =
-
-# Whether to enable asynchronous presentation (Vulkan only)
-# 0: Off, 1 (default): On
-async_presentation =
-
-# Forces the GPU to run at the maximum possible clocks (thermal constraints will still be applied).
-# 0 (default): Disabled, 1: Enabled
-force_max_clock =
-
-# Enable graphics API debugging mode.
-# 0 (default): Disabled, 1: Enabled
-debug =
-
-# Enable shader feedback.
-# 0 (default): Disabled, 1: Enabled
-renderer_shader_feedback =
-
-# Enable Nsight Aftermath crash dumps
-# 0 (default): Disabled, 1: Enabled
-nsight_aftermath =
-
-# Disable shader loop safety checks, executing the shader without loop logic changes
-# 0 (default): Disabled, 1: Enabled
-disable_shader_loop_safety_checks =
-
-# Which Vulkan physical device to use (defaults to 0)
-vulkan_device =
-
-# 0: 0.5x (360p/540p) [EXPERIMENTAL]
-# 1: 0.75x (540p/810p) [EXPERIMENTAL]
-# 2 (default): 1x (720p/1080p)
-# 3: 2x (1440p/2160p)
-# 4: 3x (2160p/3240p)
-# 5: 4x (2880p/4320p)
-# 6: 5x (3600p/5400p)
-# 7: 6x (4320p/6480p)
-resolution_setup =
-
-# Pixel filter to use when up- or down-sampling rendered frames.
-# 0: Nearest Neighbor
-# 1 (default): Bilinear
-# 2: Bicubic
-# 3: Gaussian
-# 4: ScaleForce
-# 5: AMD FidelityFX™️ Super Resolution [Vulkan Only]
-scaling_filter =
-
-# Anti-Aliasing (AA)
-# 0 (default): None, 1: FXAA
-anti_aliasing =
-
-# Whether to use fullscreen or borderless window mode
-# 0 (Windows default): Borderless window, 1 (All other default): Exclusive fullscreen
-fullscreen_mode =
-
-# Aspect ratio
-# 0: Default (16:9), 1: Force 4:3, 2: Force 21:9, 3: Force 16:10, 4: Stretch to Window
-aspect_ratio =
-
-# Anisotropic filtering
-# 0: Default, 1: 2x, 2: 4x, 3: 8x, 4: 16x
-max_anisotropy =
-
-# Whether to enable VSync or not.
-# OpenGL: Values other than 0 enable VSync
-# Vulkan: FIFO is selected if the requested mode is not supported by the driver.
-# FIFO (VSync) does not drop frames or exhibit tearing but is limited by the screen refresh rate.
-# FIFO Relaxed is similar to FIFO but allows tearing as it recovers from a slow down.
-# Mailbox can have lower latency than FIFO and does not tear but may drop frames.
-# Immediate (no synchronization) just presents whatever is available and can exhibit tearing.
-# 0: Immediate (Off), 1 (Default): Mailbox (On), 2: FIFO, 3: FIFO Relaxed
-use_vsync =
-
-# Selects the OpenGL shader backend. NV_gpu_program5 is required for GLASM. If NV_gpu_program5 is
-# not available and GLASM is selected, GLSL will be used.
-# 0: GLSL, 1 (default): GLASM, 2: SPIR-V
-shader_backend =
-
-# Whether to allow asynchronous shader building.
-# 0 (default): Off, 1: On
-use_asynchronous_shaders =
-
-# Uses reactive flushing instead of predictive flushing. Allowing a more accurate syncing of memory.
-# 0 (default): Off, 1: On
-use_reactive_flushing =
-
-# NVDEC emulation.
-# 0: Disabled, 1: CPU Decoding, 2 (default): GPU Decoding
-nvdec_emulation =
-
-# Accelerate ASTC texture decoding.
-# 0 (default): Off, 1: On
-accelerate_astc =
-
-# Turns on the speed limiter, which will limit the emulation speed to the desired speed limit value
-# 0: Off, 1: On (default)
-use_speed_limit =
-
-# Limits the speed of the game to run no faster than this value as a percentage of target speed
-# 1 - 9999: Speed limit as a percentage of target game speed. 100 (default)
-speed_limit =
-
-# Whether to use disk based shader cache
-# 0: Off, 1 (default): On
-use_disk_shader_cache =
-
-# Which gpu accuracy level to use
-# 0 (default): Normal, 1: High, 2: Extreme (Very slow)
-gpu_accuracy =
-
-# Whether to use asynchronous GPU emulation
-# 0 : Off (slow), 1 (default): On (fast)
-use_asynchronous_gpu_emulation =
-
-# Inform the guest that GPU operations completed more quickly than they did.
-# 0: Off, 1 (default): On
-use_fast_gpu_time =
-
-# Force unmodified buffers to be flushed, which can cost performance.
-# 0: Off (default), 1: On
-use_pessimistic_flushes =
-
-# Whether to use garbage collection or not for GPU caches.
-# 0 (default): Off, 1: On
-use_caches_gc =
-
-# The clear color for the renderer. What shows up on the sides of the bottom screen.
-# Must be in range of 0-255. Defaults to 0 for all.
-bg_red =
-bg_blue =
-bg_green =
-
-[Audio]
-# Which audio output engine to use.
-# auto (default): Auto-select
-# cubeb: Cubeb audio engine (if available)
-# sdl2: SDL2 audio engine (if available)
-# null: No audio output
-output_engine =
-
-# Which audio device to use.
-# auto (default): Auto-select
-output_device =
-
-# Output volume.
-# 100 (default): 100%, 0; mute
-volume =
-
-[Data Storage]
-# Whether to create a virtual SD card.
-# 1: Yes, 0 (default): No
-use_virtual_sd =
-
-# Whether or not to enable gamecard emulation
-# 1: Yes, 0 (default): No
-gamecard_inserted =
-
-# Whether or not the gamecard should be emulated as the current game
-# If 'gamecard_inserted' is 0 this setting is irrelevant
-# 1: Yes, 0 (default): No
-gamecard_current_game =
-
-# Path to an XCI file to use as the gamecard
-# If 'gamecard_inserted' is 0 this setting is irrelevant
-# If 'gamecard_current_game' is 1 this setting is irrelevant
-gamecard_path =
-
-[System]
-# Whether the system is docked
-# 1: Yes, 0 (default): No
-use_docked_mode =
-
-# Sets the seed for the RNG generator built into the switch
-# rng_seed will be ignored and randomly generated if rng_seed_enabled is false
-rng_seed_enabled =
-rng_seed =
-
-# Sets the current time (in seconds since 12:00 AM Jan 1, 1970) that will be used by the time service
-# This will auto-increment, with the time set being the time the game is started
-# This override will only occur if custom_rtc_enabled is true, otherwise the current time is used
-custom_rtc_enabled =
-custom_rtc =
-
-# Sets the systems language index
-# 0: Japanese, 1: English (default), 2: French, 3: German, 4: Italian, 5: Spanish, 6: Chinese,
-# 7: Korean, 8: Dutch, 9: Portuguese, 10: Russian, 11: Taiwanese, 12: British English, 13: Canadian French,
-# 14: Latin American Spanish, 15: Simplified Chinese, 16: Traditional Chinese, 17: Brazilian Portuguese
-language_index =
-
-# The system region that yuzu will use during emulation
-# -1: Auto-select (default), 0: Japan, 1: USA, 2: Europe, 3: Australia, 4: China, 5: Korea, 6: Taiwan
-region_index =
-
-# The system time zone that yuzu will use during emulation
-# 0: Auto-select (default), 1: Default (system archive value), Others: Index for specified time zone
-time_zone_index =
-
-# Sets the sound output mode.
-# 0: Mono, 1 (default): Stereo, 2: Surround
-sound_index =
-
-[Miscellaneous]
-# A filter which removes logs below a certain logging level.
-# Examples: *:Debug Kernel.SVC:Trace Service.*:Critical
-log_filter = *:Trace
-
-# Use developer keys
-# 0 (default): Disabled, 1: Enabled
-use_dev_keys =
-
-[Debugging]
-# Record frame time data, can be found in the log directory. Boolean value
-record_frame_times =
-# Determines whether or not yuzu will dump the ExeFS of all games it attempts to load while loading them
-dump_exefs=false
-# Determines whether or not yuzu will dump all NSOs it attempts to load while loading them
-dump_nso=false
-# Determines whether or not yuzu will save the filesystem access log.
-enable_fs_access_log=false
-# Enables verbose reporting services
-reporting_services =
-# Determines whether or not yuzu will report to the game that the emulated console is in Kiosk Mode
-# false: Retail/Normal Mode (default), true: Kiosk Mode
-quest_flag =
-# Determines whether debug asserts should be enabled, which will throw an exception on asserts.
-# false: Disabled (default), true: Enabled
-use_debug_asserts =
-# Determines whether unimplemented HLE service calls should be automatically stubbed.
-# false: Disabled (default), true: Enabled
-use_auto_stub =
-# Enables/Disables the macro JIT compiler
-disable_macro_jit=false
-# Determines whether to enable the GDB stub and wait for the debugger to attach before running.
-# false: Disabled (default), true: Enabled
-use_gdbstub=false
-# The port to use for the GDB server, if it is enabled.
-gdbstub_port=6543
-
-[WebService]
-# Whether or not to enable telemetry
-# 0: No, 1 (default): Yes
-enable_telemetry =
-# URL for Web API
-web_api_url =
-# Username and token for yuzu Web Service
-# See https://profile.yuzu-emu.org/ for more info
-yuzu_username =
-yuzu_token =
-
-[Network]
-# Name of the network interface device to use with yuzu LAN play.
-# e.g. On *nix: 'enp7s0', 'wlp6s0u1u3u3', 'lo'
-# e.g. On Windows: 'Ethernet', 'Wi-Fi'
-network_interface =
-
-[AddOns]
-# Used to disable add-ons
-# List of title IDs of games that will have add-ons disabled (separated by '|'):
-title_ids =
-# For each title ID, have a key/value pair called `disabled_<title_id>` equal to the names of the add-ons to disable (sep. by '|')
-# e.x. disabled_0100000000010000 = Update|DLC <- disables Updates and
- on Super Mario Odyssey
-)";
-} // namespace DefaultINI
-
-
-// SPDX-FileCopyrightText: 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <filesystem>
-#include <memory>
-#include <optional>
-#include <string>
-
-#include "common/settings.h"
-
-class INIReader;
-
-class Config {
-    bool LoadINI(const std::string& default_contents = "", bool retry = true);
-
-public:
-    enum class ConfigType {
-        GlobalConfig,
-        PerGameConfig,
-        InputProfile,
+#include <common/settings_common.h>
+#include "common/common_types.h"
+#include "common/settings_setting.h"
+#include "common/settings_enums.h"
+
+namespace IOSSettings {
+    struct Values {
+        Settings::Linkage linkage;
+        Settings::Setting<bool> touchscreen{linkage, true, "touchscreen", Settings::Category::Overlay};
     };
 
-    explicit Config(const std::string& config_name = "config",
-                    ConfigType config_type = ConfigType::GlobalConfig);
-    ~Config();
+    extern Values values;
 
-    void Initialize(const std::string& config_name);
-
-private:
-    /**
-     * Applies a value read from the config to a Setting.
-     *
-     * @param group The name of the INI group
-     * @param setting The yuzu setting to modify
-     */
-    template <typename Type, bool ranged>
-    void ReadSetting(const std::string& group, YuzuSettings::Setting<Type, ranged>& setting);
-
-    void ReadValues();
-
-    const ConfigType type;
-    std::unique_ptr<INIReader> config;
-    std::string config_loc;
-    const bool global;
-};
+} // namespace IOSSettings

src/ios/Eden/Wrapper/Config/Config.mm

@@ -1,330 +1,8 @@
-//
-//  Config.m - Sudachi
-//  Created by Jarrod Norwell on 13/3/2024.
-//
 
-#import "Config.h"
+#include "Config.h"
 
-// SPDX-FileCopyrightText: 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
+namespace IOSSettings {
 
-#include <memory>
-#include <optional>
-#include <sstream>
+Values values;
 
-#include <INIReader.h>
-#include "common/fs/file.h"
-#include "common/fs/fs.h"
-#include "common/fs/path_util.h"
-#include "common/logging/log.h"
-#include "common/settings.h"
-#include "common/settings_enums.h"
-#include "core/hle/service/acc/profile_manager.h"
-#include "input_common/main.h"
-
-namespace FS = Common::FS;
-
-Config::Config(const std::string& config_name, ConfigType config_type)
-    : type(config_type), global{config_type == ConfigType::GlobalConfig} {
-    Initialize(config_name);
-}
-
-Config::~Config() = default;
-
-bool Config::LoadINI(const std::string& default_contents, bool retry) {
-    void(FS::CreateParentDir(config_loc));
-    config = std::make_unique<INIReader>(FS::PathToUTF8String(config_loc));
-    const auto config_loc_str = FS::PathToUTF8String(config_loc);
-    if (config->ParseError() < 0) {
-        if (retry) {
-            LOG_WARNING(Config, "Failed to load {}. Creating file from defaults...",
-                        config_loc_str);
-
-            void(FS::CreateParentDir(config_loc));
-            void(FS::WriteStringToFile(config_loc, FS::FileType::TextFile, default_contents));
-
-            config = std::make_unique<INIReader>(config_loc_str);
-
-            return LoadINI(default_contents, false);
-        }
-        LOG_ERROR(Config, "Failed.");
-        return false;
-    }
-    LOG_INFO(Config, "Successfully loaded {}", config_loc_str);
-    return true;
-}
-
-template <>
-void Config::ReadSetting(const std::string& group, YuzuSettings::Setting<std::string>& setting) {
-    std::string setting_value = config->Get(group, setting.GetLabel(), setting.GetDefault());
-    if (setting_value.empty()) {
-        setting_value = setting.GetDefault();
-    }
-    setting = std::move(setting_value);
-}
-
-template <>
-void Config::ReadSetting(const std::string& group, YuzuSettings::Setting<bool>& setting) {
-    setting = config->GetBoolean(group, setting.GetLabel(), setting.GetDefault());
-}
-
-template <typename Type, bool ranged>
-void Config::ReadSetting(const std::string& group, YuzuSettings::Setting<Type, ranged>& setting) {
-    setting = static_cast<Type>(
-        config->GetInteger(group, setting.GetLabel(), static_cast<long>(setting.GetDefault())));
-}
-
-void Config::ReadValues() {
-    ReadSetting("ControlsGeneral", YuzuSettings::values.mouse_enabled);
-    ReadSetting("ControlsGeneral", YuzuSettings::values.touch_device);
-    ReadSetting("ControlsGeneral", YuzuSettings::values.keyboard_enabled);
-    ReadSetting("ControlsGeneral", YuzuSettings::values.debug_pad_enabled);
-    ReadSetting("ControlsGeneral", YuzuSettings::values.vibration_enabled);
-    ReadSetting("ControlsGeneral", YuzuSettings::values.enable_accurate_vibrations);
-    ReadSetting("ControlsGeneral", YuzuSettings::values.motion_enabled);
-    YuzuSettings::values.touchscreen.enabled =
-        config->GetBoolean("ControlsGeneral", "touch_enabled", true);
-    YuzuSettings::values.touchscreen.rotation_angle =
-        config->GetInteger("ControlsGeneral", "touch_angle", 0);
-    YuzuSettings::values.touchscreen.diameter_x =
-        config->GetInteger("ControlsGeneral", "touch_diameter_x", 15);
-    YuzuSettings::values.touchscreen.diameter_y =
-        config->GetInteger("ControlsGeneral", "touch_diameter_y", 15);
-
-    int num_touch_from_button_maps =
-        config->GetInteger("ControlsGeneral", "touch_from_button_map", 0);
-    if (num_touch_from_button_maps > 0) {
-        for (int i = 0; i < num_touch_from_button_maps; ++i) {
-            YuzuSettings::TouchFromButtonMap map;
-            map.name = config->Get("ControlsGeneral",
-                                   std::string("touch_from_button_maps_") + std::to_string(i) +
-                                       std::string("_name"),
-                                   "default");
-            const int num_touch_maps = config->GetInteger(
-                "ControlsGeneral",
-                std::string("touch_from_button_maps_") + std::to_string(i) + std::string("_count"),
-                0);
-            map.buttons.reserve(num_touch_maps);
-
-            for (int j = 0; j < num_touch_maps; ++j) {
-                std::string touch_mapping =
-                    config->Get("ControlsGeneral",
-                                std::string("touch_from_button_maps_") + std::to_string(i) +
-                                    std::string("_bind_") + std::to_string(j),
-                                "");
-                map.buttons.emplace_back(std::move(touch_mapping));
-            }
-
-            YuzuSettings::values.touch_from_button_maps.emplace_back(std::move(map));
-        }
-    } else {
-        YuzuSettings::values.touch_from_button_maps.emplace_back(
-            YuzuSettings::TouchFromButtonMap{"default", {}});
-        num_touch_from_button_maps = 1;
-    }
-    YuzuSettings::values.touch_from_button_map_index = std::clamp(
-        YuzuSettings::values.touch_from_button_map_index.GetValue(), 0, num_touch_from_button_maps - 1);
-
-    ReadSetting("ControlsGeneral", YuzuSettings::values.udp_input_servers);
-
-    // Data Storage
-    ReadSetting("Data Storage", YuzuSettings::values.use_virtual_sd);
-    FS::SetYuzuPath(FS::YuzuPath::NANDDir,
-                    config->Get("Data Storage", "nand_directory",
-                                FS::GetYuzuPathString(FS::YuzuPath::NANDDir)));
-    FS::SetYuzuPath(FS::YuzuPath::SDMCDir,
-                    config->Get("Data Storage", "sdmc_directory",
-                                FS::GetYuzuPathString(FS::YuzuPath::SDMCDir)));
-    FS::SetYuzuPath(FS::YuzuPath::LoadDir,
-                    config->Get("Data Storage", "load_directory",
-                                FS::GetYuzuPathString(FS::YuzuPath::LoadDir)));
-    FS::SetYuzuPath(FS::YuzuPath::DumpDir,
-                    config->Get("Data Storage", "dump_directory",
-                                FS::GetYuzuPathString(FS::YuzuPath::DumpDir)));
-    ReadSetting("Data Storage", YuzuSettings::values.gamecard_inserted);
-    ReadSetting("Data Storage", YuzuSettings::values.gamecard_current_game);
-    ReadSetting("Data Storage", YuzuSettings::values.gamecard_path);
-
-    // System
-    ReadSetting("System", YuzuSettings::values.current_user);
-    YuzuSettings::values.current_user = std::clamp<int>(YuzuSettings::values.current_user.GetValue(), 0,
-                                                    Service::Account::MAX_USERS - 1);
-
-    // Enable docked mode by default on iOS
-    YuzuSettings::values.use_docked_mode.SetValue(config->GetBoolean("System", "use_docked_mode", false)
-                                                  ? YuzuSettings::ConsoleMode::Docked
-                                                  : YuzuSettings::ConsoleMode::Handheld);
-
-    const auto rng_seed_enabled = config->GetBoolean("System", "rng_seed_enabled", false);
-    if (rng_seed_enabled) {
-        YuzuSettings::values.rng_seed.SetValue(config->GetInteger("System", "rng_seed", 0));
-    } else {
-        YuzuSettings::values.rng_seed.SetValue(0);
-    }
-    YuzuSettings::values.rng_seed_enabled.SetValue(rng_seed_enabled);
-
-    const auto custom_rtc_enabled = config->GetBoolean("System", "custom_rtc_enabled", false);
-    if (custom_rtc_enabled) {
-        YuzuSettings::values.custom_rtc = config->GetInteger("System", "custom_rtc", 0);
-    } else {
-        YuzuSettings::values.custom_rtc = 0;
-    }
-    YuzuSettings::values.custom_rtc_enabled = custom_rtc_enabled;
-
-    ReadSetting("System", YuzuSettings::values.language_index);
-    ReadSetting("System", YuzuSettings::values.region_index);
-    ReadSetting("System", YuzuSettings::values.time_zone_index);
-    ReadSetting("System", YuzuSettings::values.sound_index);
-
-    // Core
-    ReadSetting("Core", YuzuSettings::values.use_multi_core);
-    ReadSetting("Core", YuzuSettings::values.memory_layout_mode);
-
-    // Cpu
-    ReadSetting("Cpu", YuzuSettings::values.cpu_accuracy);
-    ReadSetting("Cpu", YuzuSettings::values.cpu_debug_mode);
-    ReadSetting("Cpu", YuzuSettings::values.cpuopt_page_tables);
-    ReadSetting("Cpu", YuzuSettings::values.cpuopt_block_linking);
-    ReadSetting("Cpu", YuzuSettings::values.cpuopt_return_stack_buffer);
-    ReadSetting("Cpu", YuzuSettings::values.cpuopt_fast_dispatcher);
-    ReadSetting("Cpu", YuzuSettings::values.cpuopt_context_elimination);
-    ReadSetting("Cpu", YuzuSettings::values.cpuopt_const_prop);
-    ReadSetting("Cpu", YuzuSettings::values.cpuopt_misc_ir);
-    ReadSetting("Cpu", YuzuSettings::values.cpuopt_reduce_misalign_checks);
-    ReadSetting("Cpu", YuzuSettings::values.cpuopt_fastmem);
-    ReadSetting("Cpu", YuzuSettings::values.cpuopt_fastmem_exclusives);
-    ReadSetting("Cpu", YuzuSettings::values.cpuopt_recompile_exclusives);
-    ReadSetting("Cpu", YuzuSettings::values.cpuopt_ignore_memory_aborts);
-    ReadSetting("Cpu", YuzuSettings::values.cpuopt_unsafe_unfuse_fma);
-    ReadSetting("Cpu", YuzuSettings::values.cpuopt_unsafe_reduce_fp_error);
-    ReadSetting("Cpu", YuzuSettings::values.cpuopt_unsafe_ignore_standard_fpcr);
-    ReadSetting("Cpu", YuzuSettings::values.cpuopt_unsafe_inaccurate_nan);
-    ReadSetting("Cpu", YuzuSettings::values.cpuopt_unsafe_fastmem_check);
-    ReadSetting("Cpu", YuzuSettings::values.cpuopt_unsafe_ignore_global_monitor);
-
-    // Renderer
-    ReadSetting("Renderer", YuzuSettings::values.renderer_backend);
-    ReadSetting("Renderer", YuzuSettings::values.renderer_debug);
-    ReadSetting("Renderer", YuzuSettings::values.renderer_shader_feedback);
-    ReadSetting("Renderer", YuzuSettings::values.enable_nsight_aftermath);
-    ReadSetting("Renderer", YuzuSettings::values.disable_shader_loop_safety_checks);
-    ReadSetting("Renderer", YuzuSettings::values.vulkan_device);
-
-    ReadSetting("Renderer", YuzuSettings::values.resolution_setup);
-    ReadSetting("Renderer", YuzuSettings::values.scaling_filter);
-    ReadSetting("Renderer", YuzuSettings::values.fsr_sharpening_slider);
-    ReadSetting("Renderer", YuzuSettings::values.anti_aliasing);
-    ReadSetting("Renderer", YuzuSettings::values.fullscreen_mode);
-    ReadSetting("Renderer", YuzuSettings::values.aspect_ratio);
-    ReadSetting("Renderer", YuzuSettings::values.max_anisotropy);
-    ReadSetting("Renderer", YuzuSettings::values.use_speed_limit);
-    ReadSetting("Renderer", YuzuSettings::values.speed_limit);
-    ReadSetting("Renderer", YuzuSettings::values.use_disk_shader_cache);
-    ReadSetting("Renderer", YuzuSettings::values.use_asynchronous_gpu_emulation);
-    ReadSetting("Renderer", YuzuSettings::values.vsync_mode);
-    ReadSetting("Renderer", YuzuSettings::values.shader_backend);
-    ReadSetting("Renderer", YuzuSettings::values.use_asynchronous_shaders);
-    ReadSetting("Renderer", YuzuSettings::values.nvdec_emulation);
-    ReadSetting("Renderer", YuzuSettings::values.use_fast_gpu_time);
-    ReadSetting("Renderer", YuzuSettings::values.use_vulkan_driver_pipeline_cache);
-
-    ReadSetting("Renderer", YuzuSettings::values.bg_red);
-    ReadSetting("Renderer", YuzuSettings::values.bg_green);
-    ReadSetting("Renderer", YuzuSettings::values.bg_blue);
-
-    // Use GPU accuracy normal by default on Android
-    YuzuSettings::values.gpu_accuracy = static_cast<YuzuSettings::GpuAccuracy>(config->GetInteger(
-        "Renderer", "gpu_accuracy", static_cast<u32>(YuzuSettings::GpuAccuracy::Normal)));
-
-    // Use GPU default anisotropic filtering on Android
-    YuzuSettings::values.max_anisotropy =
-        static_cast<YuzuSettings::AnisotropyMode>(config->GetInteger("Renderer", "max_anisotropy", 1));
-
-    // Disable ASTC compute by default on iOS
-    YuzuSettings::values.accelerate_astc.SetValue(
-        config->GetBoolean("Renderer", "accelerate_astc", false) ? YuzuSettings::AstcDecodeMode::Gpu
-                                                                 : YuzuSettings::AstcDecodeMode::Cpu);
-
-    // Enable asynchronous presentation by default on Android
-    YuzuSettings::values.async_presentation =
-        config->GetBoolean("Renderer", "async_presentation", true);
-
-    // Disable force_max_clock by default on Android
-    YuzuSettings::values.renderer_force_max_clock =
-        config->GetBoolean("Renderer", "force_max_clock", false);
-
-    // Disable use_reactive_flushing by default on Android
-    YuzuSettings::values.use_reactive_flushing =
-        config->GetBoolean("Renderer", "use_reactive_flushing", false);
-
-    // Audio
-    ReadSetting("Audio", YuzuSettings::values.sink_id);
-    ReadSetting("Audio", YuzuSettings::values.audio_output_device_id);
-    ReadSetting("Audio", YuzuSettings::values.volume);
-
-    // Miscellaneous
-    // log_filter has a different default here than from common
-    YuzuSettings::values.log_filter = "*:Info";
-    ReadSetting("Miscellaneous", YuzuSettings::values.use_dev_keys);
-
-    // Debugging
-    YuzuSettings::values.record_frame_times =
-        config->GetBoolean("Debugging", "record_frame_times", false);
-    ReadSetting("Debugging", YuzuSettings::values.dump_exefs);
-    ReadSetting("Debugging", YuzuSettings::values.dump_nso);
-    ReadSetting("Debugging", YuzuSettings::values.enable_fs_access_log);
-    ReadSetting("Debugging", YuzuSettings::values.reporting_services);
-    ReadSetting("Debugging", YuzuSettings::values.quest_flag);
-    ReadSetting("Debugging", YuzuSettings::values.use_debug_asserts);
-    ReadSetting("Debugging", YuzuSettings::values.use_auto_stub);
-    ReadSetting("Debugging", YuzuSettings::values.disable_macro_jit);
-    ReadSetting("Debugging", YuzuSettings::values.disable_macro_hle);
-    ReadSetting("Debugging", YuzuSettings::values.use_gdbstub);
-    ReadSetting("Debugging", YuzuSettings::values.gdbstub_port);
-
-    const auto title_list = config->Get("AddOns", "title_ids", "");
-    std::stringstream ss(title_list);
-    std::string line;
-    while (std::getline(ss, line, '|')) {
-        const auto title_id = std::strtoul(line.c_str(), nullptr, 16);
-        const auto disabled_list = config->Get("AddOns", "disabled_" + line, "");
-
-        std::stringstream inner_ss(disabled_list);
-        std::string inner_line;
-        std::vector<std::string> out;
-        while (std::getline(inner_ss, inner_line, '|')) {
-            out.push_back(inner_line);
-        }
-
-        YuzuSettings::values.disabled_addons.insert_or_assign(title_id, out);
-    }
-
-    // Web Service
-    ReadSetting("WebService", YuzuSettings::values.enable_telemetry);
-    ReadSetting("WebService", YuzuSettings::values.web_api_url);
-    ReadSetting("WebService", YuzuSettings::values.yuzu_username);
-    ReadSetting("WebService", YuzuSettings::values.yuzu_token);
-
-    // Network
-    ReadSetting("Network", YuzuSettings::values.network_interface);
-}
-
-void Config::Initialize(const std::string& config_name) {
-    const auto fs_config_loc = FS::GetYuzuPath(FS::YuzuPath::ConfigDir);
-    const auto config_file = fmt::format("{}.ini", config_name);
-
-    switch (type) {
-    case ConfigType::GlobalConfig:
-        config_loc = FS::PathToUTF8String(fs_config_loc / config_file);
-        break;
-    case ConfigType::PerGameConfig:
-        config_loc = FS::PathToUTF8String(fs_config_loc / "custom" / FS::ToU8String(config_file));
-        break;
-    case ConfigType::InputProfile:
-        config_loc = FS::PathToUTF8String(fs_config_loc / "input" / config_file);
-        LoadINI(DefaultINI::android_config_file);
-        return;
-    }
-    LoadINI(DefaultINI::android_config_file);
-    ReadValues();
-}
+} // namespace IOSSettings

src/ios/Eden/Wrapper/DirectoryManager/DirectoryManager.mm

@@ -4,7 +4,6 @@
 //
 
 #import <Foundation/Foundation.h>
-
 #import "DirectoryManager.h"
 
 NSURL *DocumentsDirectory() {