Custom configuration for each game #632
@ -42,31 +42,12 @@ namespace Ryujinx.Ava
|
|||||||
|
|
|||||||
List<string> arguments = CommandLineState.Arguments.ToList();
|
List<string> arguments = CommandLineState.Arguments.ToList();
|
||||||
string executableDirectory = AppDomain.CurrentDomain.BaseDirectory;
|
string executableDirectory = AppDomain.CurrentDomain.BaseDirectory;
|
||||||
|
|
||||||
// On macOS we perform the update at relaunch.
|
|
||||||
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
|||||||
if (OperatingSystem.IsMacOS())
|
|
||||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
|||||||
{
|
|
||||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
|||||||
string baseBundlePath = Path.GetFullPath(Path.Combine(executableDirectory, "..", ".."));
|
|
||||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
|||||||
string newBundlePath = Path.Combine(_updateDir, "Ryujinx.app");
|
|
||||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
|||||||
string updaterScriptPath = Path.Combine(newBundlePath, "Contents", "Resources", "updater.sh");
|
|
||||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
|||||||
string currentPid = Environment.ProcessId.ToString();
|
|
||||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
|||||||
|
|
||||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
|||||||
arguments.InsertRange(0, new List<string> { updaterScriptPath, baseBundlePath, newBundlePath, currentPid });
|
|
||||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
|||||||
Process.Start("/bin/bash", arguments);
|
|
||||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
|||||||
}
|
|
||||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
|||||||
else
|
|
||||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
|||||||
{
|
|
||||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
|||||||
var dialogTask = taskDialog.ShowAsync(true);
|
var dialogTask = taskDialog.ShowAsync(true);
|
||||||
await Task.Delay(500);
|
await Task.Delay(500);
|
||||||
|
|
||||||
// Find the process name.
|
// Find the process name.
|
||||||
string ryuName = Path.GetFileName(Environment.ProcessPath) ?? string.Empty;
|
string ryuName = Path.GetFileName(Environment.ProcessPath) ?? string.Empty;
|
||||||
|
|
||||||
// Some operating systems can see the renamed executable, so strip off the .ryuold if found.
|
|
||||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
|||||||
if (ryuName.EndsWith(".ryuold"))
|
|
||||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
|||||||
{
|
|
||||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
|||||||
ryuName = ryuName[..^7];
|
|
||||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
|||||||
}
|
|
||||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
|||||||
|
|
||||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
|||||||
// Fallback if the executable could not be found.
|
// Fallback if the executable could not be found.
|
||||||
if (ryuName.Length == 0 || !Path.Exists(Path.Combine(executableDirectory, ryuName)))
|
if (ryuName.Length == 0 || !Path.Exists(Path.Combine(executableDirectory, ryuName)))
|
||||||
{
|
{
|
||||||
@ -87,7 +68,7 @@ namespace Ryujinx.Ava
|
|||||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
|||||||
processStart.ArgumentList.Add(gamePath);
|
processStart.ArgumentList.Add(gamePath);
|
||||||
|
|
||||||
Process.Start(processStart);
|
Process.Start(processStart);
|
||||||
}
|
|
||||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
|||||||
Environment.Exit(0);
|
Environment.Exit(0);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
|||||||
Loading…
x
Reference in New Issue
Block a user
This is a rebooter, not an updater; the update stuff should probably get removed(?)
This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
There is no need to delete it. At least I made it so that it works in this code
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting