forked from RPCS3/rpcs3
-
Notifications
You must be signed in to change notification settings - Fork 16
/
system_config.h
308 lines (258 loc) · 17.1 KB
/
system_config.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
#pragma once
#include "system_config_types.h"
#include "Utilities/Config.h"
enum CellNetCtlState : s32;
enum CellSysutilLicenseArea : s32;
enum CellSysutilLang : s32;
enum CellKbMappingType : s32;
struct cfg_root : cfg::node
{
struct node_core : cfg::node
{
private:
/** We don't wanna include the sysinfo header here */
bool has_rtm() const;
public:
static constexpr bool thread_scheduler_enabled_def =
#ifdef _WIN32
true;
#else
false;
#endif
node_core(cfg::node* _this) : cfg::node(_this, "Core") {}
cfg::_enum<ppu_decoder_type> ppu_decoder{ this, "PPU Decoder", ppu_decoder_type::llvm };
cfg::_int<1, 8> ppu_threads{ this, "PPU Threads", 2 }; // Amount of PPU threads running simultaneously (must be 2)
cfg::_bool ppu_debug{ this, "PPU Debug" };
cfg::_bool llvm_logs{ this, "Save LLVM logs" };
cfg::string llvm_cpu{ this, "Use LLVM CPU" };
cfg::_int<0, INT32_MAX> llvm_threads{ this, "Max LLVM Compile Threads", 0 };
cfg::_bool ppu_llvm_greedy_mode{ this, "PPU LLVM Greedy Mode", false, false };
cfg::_bool thread_scheduler_enabled{ this, "Enable thread scheduler", thread_scheduler_enabled_def };
cfg::_bool set_daz_and_ftz{ this, "Set DAZ and FTZ", false };
cfg::_enum<spu_decoder_type> spu_decoder{ this, "SPU Decoder", spu_decoder_type::llvm };
cfg::_bool lower_spu_priority{ this, "Lower SPU thread priority" };
cfg::_bool spu_getllar_polling_detection{ this, "SPU GETLLAR polling detection", false, true };
cfg::_bool spu_debug{ this, "SPU Debug" };
cfg::_bool mfc_debug{ this, "MFC Debug" };
cfg::_int<0, 6> preferred_spu_threads{ this, "Preferred SPU Threads", 0, true }; // Number of hardware threads dedicated to heavy simultaneous spu tasks
cfg::_int<0, 16> spu_delay_penalty{ this, "SPU delay penalty", 3 }; // Number of milliseconds to block a thread if a virtual 'core' isn't free
cfg::_bool spu_loop_detection{ this, "SPU loop detection", true, true }; // Try to detect wait loops and trigger thread yield
cfg::_int<0, 6> max_spurs_threads{ this, "Max SPURS Threads", 6 }; // HACK. If less then 6, max number of running SPURS threads in each thread group.
cfg::_enum<spu_block_size_type> spu_block_size{ this, "SPU Block Size", spu_block_size_type::safe };
cfg::_bool spu_accurate_getllar{ this, "Accurate GETLLAR", false, true };
cfg::_bool spu_accurate_dma{ this, "Accurate SPU DMA", false };
cfg::_bool accurate_cache_line_stores{ this, "Accurate Cache Line Stores", false };
cfg::_bool rsx_accurate_res_access{this, "Accurate RSX reservation access", false, true};
cfg::_bool spu_verification{ this, "SPU Verification", true }; // Should be enabled
cfg::_bool spu_cache{ this, "SPU Cache", true };
cfg::_bool spu_prof{ this, "SPU Profiler", false };
cfg::_enum<tsx_usage> enable_TSX{ this, "Enable TSX", has_rtm() ? tsx_usage::enabled : tsx_usage::disabled }; // Enable TSX. Forcing this on Haswell/Broadwell CPUs should be used carefully
cfg::_bool spu_accurate_xfloat{ this, "Accurate xfloat", false };
cfg::_bool spu_approx_xfloat{ this, "Approximate xfloat", true };
cfg::_bool llvm_accurate_dfma{ this, "LLVM Accurate DFMA", true }; // Enable accurate double-precision FMA for CPUs which do not support it natively
cfg::_bool llvm_ppu_jm_handling{ this, "PPU LLVM Java Mode Handling", false }; // Respect current Java Mode for alti-vec ops by PPU LLVM
cfg::_int<-1, 14> ppu_128_reservations_loop_max_length{ this, "Accurate PPU 128-byte Reservation Op Max Length", 0, true }; // -1: Always accurate, 0: Never accurate, 1-14: max accurate loop length
cfg::_bool llvm_ppu_accurate_vector_nan{ this, "PPU LLVM Accurate Vector NaN values", false };
cfg::_int<-64, 64> stub_ppu_traps{ this, "Stub PPU Traps", 0, true }; // Hack, skip PPU traps for rare cases where the trap is continueable (specify relative instructions to skip)
cfg::_bool debug_console_mode{ this, "Debug Console Mode", false }; // Debug console emulation, not recommended
cfg::_bool hook_functions{ this, "Hook static functions" };
cfg::set_entry libraries_control{ this, "Libraries Control" }; // Override HLE/LLE behaviour of selected libs
cfg::_bool hle_lwmutex{ this, "HLE lwmutex" }; // Force alternative lwmutex/lwcond implementation
cfg::uint64 spu_llvm_lower_bound{ this, "SPU LLVM Lower Bound" };
cfg::uint64 spu_llvm_upper_bound{ this, "SPU LLVM Upper Bound", 0xffffffffffffffff };
cfg::uint64 tx_limit1_ns{this, "TSX Transaction First Limit", 800}; // In nanoseconds
cfg::uint64 tx_limit2_ns{this, "TSX Transaction Second Limit", 2000}; // In nanoseconds
cfg::_int<10, 3000> clocks_scale{ this, "Clocks scale", 100, true }; // Changing this from 100 (percentage) may affect game speed in unexpected ways
cfg::_enum<sleep_timers_accuracy_level> sleep_timers_accuracy{ this, "Sleep Timers Accuracy",
#ifdef __linux__
sleep_timers_accuracy_level::_as_host, true };
#else
sleep_timers_accuracy_level::_usleep, true };
#endif
cfg::uint64 perf_report_threshold{this, "Performance Report Threshold", 500, true}; // In µs, 0.5ms = default, 0 = everything
cfg::_bool perf_report{this, "Enable Performance Report", false, true}; // Show certain perf-related logs
} core{ this };
struct node_vfs : cfg::node
{
node_vfs(cfg::node* _this) : cfg::node(_this, "VFS") {}
std::string get(const cfg::string&, const char*) const;
cfg::string emulator_dir{ this, "$(EmulatorDir)" }; // Default (empty): taken from fs::get_config_dir()
cfg::string dev_hdd0{ this, "/dev_hdd0/", "$(EmulatorDir)dev_hdd0/" };
cfg::string dev_hdd1{ this, "/dev_hdd1/", "$(EmulatorDir)dev_hdd1/" };
cfg::string dev_flash{ this, "/dev_flash/", "$(EmulatorDir)dev_flash/" };
cfg::string dev_usb000{ this, "/dev_usb000/", "$(EmulatorDir)dev_usb000/" };
cfg::string dev_bdvd{ this, "/dev_bdvd/" }; // Not mounted
cfg::string app_home{ this, "/app_home/" }; // Not mounted
std::string get_dev_flash() const
{
return get(dev_flash, "dev_flash/");
}
cfg::_bool host_root{ this, "Enable /host_root/" };
cfg::_bool init_dirs{ this, "Initialize Directories", true };
cfg::_bool limit_cache_size{ this, "Limit disk cache size", false };
cfg::_int<0, 10240> cache_max_size{ this, "Disk cache maximum size (MB)", 5120 };
} vfs{ this };
struct node_video : cfg::node
{
node_video(cfg::node* _this) : cfg::node(_this, "Video") {}
cfg::_enum<video_renderer> renderer{ this, "Renderer", video_renderer::opengl };
cfg::_enum<video_resolution> resolution{ this, "Resolution", video_resolution::_720 };
cfg::_enum<video_aspect> aspect_ratio{ this, "Aspect ratio", video_aspect::_16_9 };
cfg::_enum<frame_limit_type> frame_limit{ this, "Frame limit", frame_limit_type::_auto, true };
cfg::_enum<msaa_level> antialiasing_level{ this, "MSAA", msaa_level::_auto };
cfg::_enum<shader_mode> shadermode{ this, "Shader Mode", shader_mode::async_recompiler };
cfg::_bool write_color_buffers{ this, "Write Color Buffers" };
cfg::_bool write_depth_buffer{ this, "Write Depth Buffer" };
cfg::_bool read_color_buffers{ this, "Read Color Buffers" };
cfg::_bool read_depth_buffer{ this, "Read Depth Buffer" };
cfg::_bool log_programs{ this, "Log shader programs" };
cfg::_bool vsync{ this, "VSync" };
cfg::_bool debug_output{ this, "Debug output" };
cfg::_bool overlay{ this, "Debug overlay", false, true };
cfg::_bool gl_legacy_buffers{ this, "Use Legacy OpenGL Buffers" };
cfg::_bool use_gpu_texture_scaling{ this, "Use GPU texture scaling", false };
cfg::_bool stretch_to_display_area{ this, "Stretch To Display Area", false, true };
cfg::_bool force_high_precision_z_buffer{ this, "Force High Precision Z buffer" };
cfg::_bool strict_rendering_mode{ this, "Strict Rendering Mode" };
cfg::_bool disable_zcull_queries{ this, "Disable ZCull Occlusion Queries", false, true };
cfg::_bool disable_vertex_cache{ this, "Disable Vertex Cache", false };
cfg::_bool disable_FIFO_reordering{ this, "Disable FIFO Reordering", false };
cfg::_bool frame_skip_enabled{ this, "Enable Frame Skip", false, true };
cfg::_bool force_cpu_blit_processing{ this, "Force CPU Blit", false, true }; // Debugging option
cfg::_bool disable_on_disk_shader_cache{ this, "Disable On-Disk Shader Cache", false };
cfg::_bool disable_vulkan_mem_allocator{ this, "Disable Vulkan Memory Allocator", false };
cfg::_bool full_rgb_range_output{ this, "Use full RGB output range", true, true }; // Video out dynamic range
cfg::_bool strict_texture_flushing{ this, "Strict Texture Flushing", false };
cfg::_bool disable_native_float16{ this, "Disable native float16 support", false };
cfg::_bool multithreaded_rsx{ this, "Multithreaded RSX", false };
cfg::_bool relaxed_zcull_sync{ this, "Relaxed ZCULL Sync", false };
cfg::_bool enable_3d{ this, "Enable 3D", false };
cfg::_bool debug_program_analyser{ this, "Debug Program Analyser", false };
cfg::_int<1, 8> consecutive_frames_to_draw{ this, "Consecutive Frames To Draw", 1, true};
cfg::_int<1, 8> consecutive_frames_to_skip{ this, "Consecutive Frames To Skip", 1, true};
cfg::_int<50, 800> resolution_scale_percent{ this, "Resolution Scale", 100 };
cfg::uint<0, 16> anisotropic_level_override{ this, "Anisotropic Filter Override", 0, true };
cfg::_int<-16, 16> texture_lod_bias{ this, "Texture LOD Bias Addend", 0, true };
cfg::_int<1, 1024> min_scalable_dimension{ this, "Minimum Scalable Dimension", 16 };
cfg::_int<0, 16> shader_compiler_threads_count{ this, "Shader Compiler Threads", 0 };
cfg::_int<0, 30000000> driver_recovery_timeout{ this, "Driver Recovery Timeout", 1000000, true };
cfg::_int<0, 16667> driver_wakeup_delay{ this, "Driver Wake-Up Delay", 1, true };
cfg::_int<1, 1800> vblank_rate{ this, "Vblank Rate", 60, true }; // Changing this from 60 may affect game speed in unexpected ways
cfg::_bool decr_memory_layout{ this, "DECR memory layout", false}; // Force enable increased allowed main memory range as DECR console
struct node_vk : cfg::node
{
node_vk(cfg::node* _this) : cfg::node(_this, "Vulkan") {}
cfg::string adapter{ this, "Adapter" };
cfg::_bool force_fifo{ this, "Force FIFO present mode" };
cfg::_bool force_primitive_restart{ this, "Force primitive restart flag" };
cfg::_bool force_disable_exclusive_fullscreen_mode{this, "Force Disable Exclusive Fullscreen Mode"};
cfg::_bool asynchronous_texture_streaming{ this, "Asynchronous Texture Streaming 2", false };
cfg::_enum<vk_gpu_scheduler_mode> asynchronous_scheduler{ this, "Asynchronous Queue Scheduler", vk_gpu_scheduler_mode::device };
} vk{ this };
struct node_perf_overlay : cfg::node
{
node_perf_overlay(cfg::node* _this) : cfg::node(_this, "Performance Overlay") {}
cfg::_bool perf_overlay_enabled{ this, "Enabled", false, true };
cfg::_bool framerate_graph_enabled{ this, "Enable Framerate Graph", false, true };
cfg::_bool frametime_graph_enabled{ this, "Enable Frametime Graph", false, true };
cfg::uint<2, 6000> framerate_datapoint_count{ this, "Framerate datapoints", 50, true };
cfg::uint<2, 6000> frametime_datapoint_count{ this, "Frametime datapoints", 170, true };
cfg::_enum<detail_level> level{ this, "Detail level", detail_level::medium, true };
cfg::uint<1, 5000> update_interval{ this, "Metrics update interval (ms)", 350, true };
cfg::uint<4, 36> font_size{ this, "Font size (px)", 10, true };
cfg::_enum<screen_quadrant> position{ this, "Position", screen_quadrant::top_left, true };
cfg::string font{ this, "Font", "n023055ms.ttf", true };
cfg::uint<0, 1280> margin_x{ this, "Horizontal Margin (px)", 50, true }; // horizontal distance to the screen border relative to the screen_quadrant in px
cfg::uint<0, 720> margin_y{ this, "Vertical Margin (px)", 50, true }; // vertical distance to the screen border relative to the screen_quadrant in px
cfg::_bool center_x{ this, "Center Horizontally", false, true };
cfg::_bool center_y{ this, "Center Vertically", false, true };
cfg::uint<0, 100> opacity{ this, "Opacity (%)", 70, true };
cfg::string color_body{ this, "Body Color (hex)", "#FFE138FF", true };
cfg::string background_body{ this, "Body Background (hex)", "#002339FF", true };
cfg::string color_title{ this, "Title Color (hex)", "#F26C24FF", true };
cfg::string background_title{ this, "Title Background (hex)", "#00000000", true };
} perf_overlay{ this };
struct node_shader_compilation_hint : cfg::node
{
node_shader_compilation_hint(cfg::node* _this) : cfg::node(_this, "Shader Compilation Hint") {}
cfg::_int<0, 1280> pos_x{ this, "Position X (px)", 20, true }; // horizontal position starting from the upper border in px
cfg::_int<0, 720> pos_y{ this, "Position Y (px)", 690, true }; // vertical position starting from the left border in px
} shader_compilation_hint{ this };
struct node_shader_preloading_dialog : cfg::node
{
node_shader_preloading_dialog(cfg::node* _this) : cfg::node(_this, "Shader Loading Dialog") {}
cfg::_bool use_custom_background{ this, "Allow custom background", true, true };
cfg::_int<0, 100> darkening_strength{ this, "Darkening effect strength", 30, true };
cfg::_int<0, 100> blur_strength{ this, "Blur effect strength", 0, true };
} shader_preloading_dialog{ this };
} video{ this };
struct node_audio : cfg::node
{
node_audio(cfg::node* _this) : cfg::node(_this, "Audio") {}
cfg::_enum<audio_renderer> renderer{ this, "Renderer",
#ifdef _WIN32
audio_renderer::xaudio, true };
#elif HAVE_FAUDIO
audio_renderer::faudio, true };
#else
audio_renderer::openal, true };
#endif
cfg::_bool dump_to_file{ this, "Dump to file" };
cfg::_bool convert_to_u16{ this, "Convert to 16 bit", false, true };
cfg::_enum<audio_downmix> audio_channel_downmix{ this, "Audio Channels", audio_downmix::downmix_to_stereo, true };
cfg::_int<1, 128> start_threshold{ this, "Start Threshold", 1, true }; // TODO: used only by ALSA, should probably be removed once ALSA is upgraded
cfg::_int<0, 200> volume{ this, "Master Volume", 100, true };
cfg::_bool enable_buffering{ this, "Enable Buffering", true, true };
cfg::_int <4, 250> desired_buffer_duration{ this, "Desired Audio Buffer Duration", 100, true };
cfg::_int<1, 1000> sampling_period_multiplier{ this, "Sampling Period Multiplier", 100, true };
cfg::_bool enable_time_stretching{ this, "Enable Time Stretching", false, true };
cfg::_int<0, 100> time_stretching_threshold{ this, "Time Stretching Threshold", 75, true };
cfg::_enum<microphone_handler> microphone_type{ this, "Microphone Type", microphone_handler::null };
cfg::string microphone_devices{ this, "Microphone Devices", "@@@@@@@@@@@@" };
} audio{ this };
struct node_io : cfg::node
{
node_io(cfg::node* _this) : cfg::node(_this, "Input/Output") {}
cfg::_enum<keyboard_handler> keyboard{ this, "Keyboard", keyboard_handler::null };
cfg::_enum<mouse_handler> mouse{ this, "Mouse", mouse_handler::basic };
cfg::_enum<camera_handler> camera{ this, "Camera", camera_handler::null };
cfg::_enum<fake_camera_type> camera_type{ this, "Camera type", fake_camera_type::unknown };
cfg::_enum<move_handler> move{ this, "Move", move_handler::null };
cfg::_enum<buzz_handler> buzz{ this, "Buzz emulated controller", buzz_handler::null };
} io{ this };
struct node_sys : cfg::node
{
node_sys(cfg::node* _this) : cfg::node(_this, "System") {}
cfg::_enum<CellSysutilLicenseArea> license_area{ this, "License Area", CellSysutilLicenseArea{1} }; // CELL_SYSUTIL_LICENSE_AREA_A
cfg::_enum<CellSysutilLang> language{ this, "Language", CellSysutilLang{1} }; // CELL_SYSUTIL_LANG_ENGLISH_US
cfg::_enum<CellKbMappingType> keyboard_type{ this, "Keyboard Type", CellKbMappingType{0} }; // CELL_KB_MAPPING_101 = US
cfg::_enum<enter_button_assign> enter_button_assignment{ this, "Enter button assignment", enter_button_assign::cross };
cfg::_int<-60*60*24*365*100LL, 60*60*24*365*100LL> console_time_offset{ this, "Console time offset (s)", 0 }; // console time offset, limited to +/-100years
} sys{ this };
struct node_net : cfg::node
{
node_net(cfg::node* _this) : cfg::node(_this, "Net") {}
cfg::_enum<np_internet_status> net_active{this, "Internet enabled", np_internet_status::disabled};
cfg::string ip_address{this, "IP address", "0.0.0.0"};
cfg::string dns{this, "DNS address", "8.8.8.8"};
cfg::string swap_list{this, "IP swap list", ""};
cfg::_enum<np_psn_status> psn_status{this, "PSN status", np_psn_status::disabled};
} net{this};
struct node_misc : cfg::node
{
node_misc(cfg::node* _this) : cfg::node(_this, "Miscellaneous") {}
cfg::_bool autostart{ this, "Automatically start games after boot", true, true };
cfg::_bool autoexit{ this, "Exit RPCS3 when process finishes", false, true };
cfg::_bool start_fullscreen{ this, "Start games in fullscreen mode", false, true };
cfg::_bool prevent_display_sleep{ this, "Prevent display sleep while running games", true, true };
cfg::_bool show_trophy_popups{ this, "Show trophy popups", true, true };
cfg::_bool show_shader_compilation_hint{ this, "Show shader compilation hint", true, true };
cfg::_bool use_native_interface{ this, "Use native user interface", true };
cfg::string gdb_server{ this, "GDB Server", "127.0.0.1:2345" };
cfg::_bool silence_all_logs{ this, "Silence All Logs", false, true };
cfg::string title_format{ this, "Window Title Format", "FPS: %F | %R | %V | %T [%t]", true };
} misc{ this };
cfg::log_entry log{ this, "Log" };
std::string name;
};
extern cfg_root g_cfg;