LaunchSettings: add an option to use fake EGL exe

Author: loathingKernel

rare/commands/launcher/lgd_helper.py

@@ -109,19 +109,18 @@ def get_game_params(rgame: RareGameSlim, init: InitParams, launch: LaunchParams)
     full_params = []
     full_params.extend(params.launch_command)
     if 'LEGENDARY_WRAPPER_EXE' in params.environment:
-        lgd_wrapper = params.environment.pop('LEGENDARY_WRAPPER_EXE').strip()
-        if os.path.isfile(lgd_wrapper):
+        lgd_wrapper = params.environment.pop('LEGENDARY_WRAPPER_EXE', '').strip()
+        if lgd_wrapper and os.path.isfile(lgd_wrapper):
             full_params.append(lgd_wrapper)
     full_params.append(os.path.join(params.game_directory, params.game_executable))
     full_params.extend(params.game_parameters)
     full_params.extend(params.egl_parameters)
     full_params.extend(params.user_parameters)
 
-    exe, init, env = prepare_process(full_params, params.environment)
-
-    launch.executable = exe
-    launch.arguments = init
-    launch.environment = env
+    _exe, _init, _env = prepare_process(full_params, params.environment)
+    launch.executable = _exe
+    launch.arguments = _init
+    launch.environment = _env
     launch.working_directory = params.working_directory
 
     return launch

rare/components/tabs/library/details/game.py

@@ -13,6 +13,7 @@
 from rare.models.settings import RareAppSettings
 from rare.shared import RareCore
 from rare.utils import config_helper as config
+from rare.utils.wrapper_exe import wrapper_path
 from rare.widgets.indicator_edit import IndicatorReasonsCommon, PathEdit
 
 logger = getLogger('LocalGameSettings')
@@ -34,13 +35,13 @@ def __init__(self, rcore: RareCore, parent=None):
         self.skip_update_combo.addItem(self.tr('Default'), None)
         self.skip_update_combo.addItem(self.tr('No'), 'false')
         self.skip_update_combo.addItem(self.tr('Yes'), 'true')
-        self.skip_update_combo.currentIndexChanged.connect(self.__skip_update_changed)
+        self.skip_update_combo.currentIndexChanged.connect(self._skip_update_changed)
 
         self.offline_combo = QComboBox(self)
         self.offline_combo.addItem(self.tr('Default'), None)
         self.offline_combo.addItem(self.tr('No'), 'false')
         self.offline_combo.addItem(self.tr('Yes'), 'true')
-        self.offline_combo.currentIndexChanged.connect(self.__offline_changed)
+        self.offline_combo.currentIndexChanged.connect(self._offline_changed)
 
         self.override_exe_name_filters: tuple[str, ...] = (
             '*.exe',
@@ -54,14 +55,14 @@ def __init__(self, rcore: RareCore, parent=None):
             file_mode=QFileDialog.FileMode.ExistingFile,
             name_filters=self.override_exe_name_filters,
             placeholder=self.tr('Relative path to the replacement executable'),
-            edit_func=self.__override_exe_edit_callback,
-            save_func=self.__override_exe_save_callback,
+            edit_func=self._override_exe_edit_callback,
+            save_func=self._override_exe_save_callback,
             parent=self,
         )
 
         self.launch_params_edit = QLineEdit(self)
         self.launch_params_edit.setPlaceholderText(self.tr('Game specific command line arguments'))
-        self.launch_params_edit.textChanged.connect(self.__launch_params_changed)
+        self.launch_params_edit.textChanged.connect(self._launch_params_changed)
 
         self.main_layout.insertRow(0, self.tr('Skip update check'), self.skip_update_combo)
         self.main_layout.insertRow(1, self.tr('Offline mode'), self.offline_combo)
@@ -94,11 +95,11 @@ def showEvent(self, a0: QShowEvent):
         return super().showEvent(a0)
 
     @Slot(int)
-    def __skip_update_changed(self, index):
+    def _skip_update_changed(self, index):
         data = self.skip_update_combo.itemData(index, Qt.ItemDataRole.UserRole)
         config.adjust_option(self.app_name, 'skip_update_check', data)
 
-    def __override_exe_edit_callback(self, path: str) -> tuple[bool, str, int]:
+    def _override_exe_edit_callback(self, path: str) -> tuple[bool, str, int]:
         if not path or self.igame is None:
             return True, path, IndicatorReasonsCommon.VALID
         if not os.path.isabs(path):
@@ -116,17 +117,25 @@ def __override_exe_edit_callback(self, path: str) -> tuple[bool, str, int]:
         path = os.path.relpath(path, self.igame.install_path)
         return True, path, IndicatorReasonsCommon.VALID
 
-    def __override_exe_save_callback(self, path: str):
+    def _override_exe_save_callback(self, path: str):
         config.adjust_option(self.app_name, 'override_exe', path)
 
     @Slot(int)
-    def __offline_changed(self, index):
+    def _offline_changed(self, index):
         data = self.skip_update_combo.itemData(index, Qt.ItemDataRole.UserRole)
         config.adjust_option(self.app_name, 'offline', data)
 
-    def __launch_params_changed(self, value) -> None:
+    def _launch_params_changed(self, value) -> None:
         config.adjust_option(self.app_name, 'start_params', value)
 
+    @Slot(Qt.CheckState)
+    def _lgd_wrapper_check_changed(self, state: Qt.CheckState):
+        _wrapper = str(wrapper_path())
+        config.adjust_envvar_with_global(
+            self.app_name, 'LEGENDARY_WRAPPER_EXE', _wrapper if state == Qt.CheckState.Checked else ''
+        )
+        self.environ_changed.emit('LEGENDARY_WRAPPER_EXE')
+
     def load_settings(self, rgame: RareGame):
         self.game = rgame.game
         self.igame = rgame.igame

rare/components/tabs/settings/game.py

@@ -1,4 +1,4 @@
-from PySide6.QtCore import Qt
+from PySide6.QtCore import Qt, Signal
 from PySide6.QtGui import QHideEvent
 from PySide6.QtWidgets import QVBoxLayout, QWidget
 
@@ -12,6 +12,9 @@
 
 
 class GameSettingsBase(QWidget, SideTabContents):
+    # str: option key
+    environ_changed: Signal = Signal(str)
+
     def __init__(
         self,
         settings: RareAppSettings,
@@ -26,6 +29,7 @@ def __init__(
         self.app_name: str = 'default'
 
         self.launch = launch_widget(rcore, self)
+        self.launch.environ_changed.connect(self.environ_changed)
 
         self.main_layout = QVBoxLayout(self)
         self.main_layout.addWidget(self.launch, stretch=0)

rare/components/tabs/settings/widgets/launch.py

@@ -3,7 +3,7 @@
 import shutil
 from typing import TypeVar
 
-from PySide6.QtCore import Qt, Slot
+from PySide6.QtCore import Qt, Signal, Slot
 from PySide6.QtGui import QShowEvent
 from PySide6.QtWidgets import (
     QCheckBox,
@@ -16,12 +16,16 @@
 
 import rare.utils.config_helper as config
 from rare.shared import RareCore
+from rare.utils.wrapper_exe import wrapper_path
 from rare.widgets.indicator_edit import IndicatorReasonsCommon, PathEdit
 
 from .wrappers import WrapperSettings
 
 
 class LaunchSettingsBase(QGroupBox):
+    # str: option key
+    environ_changed: Signal = Signal(str)
+
     def __init__(self, rcore: RareCore, wrapper_widget: type[WrapperSettings], parent=None):
         super(LaunchSettingsBase, self).__init__(parent=parent)
         self.setTitle(self.tr('Launch'))
@@ -33,21 +37,21 @@ def __init__(self, rcore: RareCore, wrapper_widget: type[WrapperSettings], paren
             path='',
             placeholder=self.tr('Path to a script or program to run before the game'),
             file_mode=QFileDialog.FileMode.ExistingFile,
-            edit_func=self.__prelaunch_cmd_edit_callback,
-            save_func=self.__prelaunch_cmd_save_callback,
+            edit_func=self._prelaunch_cmd_edit_callback,
+            save_func=self._prelaunch_cmd_save_callback,
         )
 
         self.prelaunch_args = QLineEdit('')
         self.prelaunch_args.setPlaceholderText(self.tr('Arguments to the script or program to run before the game'))
         self.prelaunch_args.setToolTip(self.prelaunch_args.placeholderText())
-        self.prelaunch_args.textChanged.connect(self.__prelaunch_changed)
+        self.prelaunch_args.textChanged.connect(self._prelaunch_changed)
 
         font = self.font()
         font.setItalic(True)
 
         self.prelaunch_check = QCheckBox(self.tr('Wait for the pre-launch command to finish before launching the game'))
         self.prelaunch_check.setFont(font)
-        self.prelaunch_check.checkStateChanged.connect(self.__prelauch_check_changed)
+        self.prelaunch_check.checkStateChanged.connect(self._prelauch_check_changed)
 
         prelaunch_layout = QVBoxLayout()
         prelaunch_layout.addWidget(self.prelaunch_cmd)
@@ -61,6 +65,13 @@ def __init__(self, rcore: RareCore, wrapper_widget: type[WrapperSettings], paren
 
         self.wrappers_widget = wrapper_widget(rcore, self)
 
+        self.lgd_wrapper = QCheckBox(
+            self.tr('Use "EpicGamesLauncher.exe" shim for compatibility with third-party launchers (Rockstar etc.)')
+        )
+        self.lgd_wrapper.setFont(font)
+        self.lgd_wrapper.checkStateChanged.connect(self._lgd_wrapper_check_changed)
+
+        self.main_layout.addRow(self.tr('Use fake EGL'), self.lgd_wrapper)
         self.main_layout.addRow(self.tr('Wrappers'), self.wrappers_widget)
         self.main_layout.addRow(self.tr('Pre-launch'), prelaunch_layout)
 
@@ -77,31 +88,36 @@ def showEvent(self, a0: QShowEvent):
         self.prelaunch_check.setChecked(wait)
         self.prelaunch_check.setEnabled(bool(command))
 
+        wrapper = config.get_envvar_with_global(self.app_name, 'LEGENDARY_WRAPPER_EXE', fallback=False)
+
+        self.lgd_wrapper.setEnabled(wrapper_path().exists())
+        self.lgd_wrapper.setChecked(wrapper_path().exists() and bool(wrapper) and os.path.exists(wrapper))
+
         return super().showEvent(a0)
 
     @Slot()
     def tool_enabled(self):
         self.wrappers_widget.update_state()
 
     @staticmethod
-    def __prelaunch_cmd_edit_callback(text: str) -> tuple[bool, str, int]:
+    def _prelaunch_cmd_edit_callback(text: str) -> tuple[bool, str, int]:
         if not text.strip():
             return True, text, IndicatorReasonsCommon.UNDEFINED
         if not os.path.isfile(text) and not shutil.which(text):
             return False, text, IndicatorReasonsCommon.FILE_NOT_EXISTS
         else:
             return True, text, IndicatorReasonsCommon.VALID
 
-    def __prelaunch_cmd_save_callback(self, text):
+    def _prelaunch_cmd_save_callback(self, text):
         self.prelaunch_check.setEnabled(bool(text))
-        self.__prelaunch_changed()
+        self._prelaunch_changed()
 
     @Slot(Qt.CheckState)
-    def __prelauch_check_changed(self, state: Qt.CheckState):
+    def _prelauch_check_changed(self, state: Qt.CheckState):
         config.set_boolean(self.app_name, 'pre_launch_wait', state != Qt.CheckState.Unchecked)
 
     @Slot()
-    def __prelaunch_changed(self):
+    def _prelaunch_changed(self):
         command = self.prelaunch_cmd.text().strip()
         if not command:
             config.adjust_option(self.app_name, 'pre_launch_command', command)
@@ -111,5 +127,11 @@ def __prelaunch_changed(self):
         arguments = self.prelaunch_args.text().strip()
         config.adjust_option(self.app_name, 'pre_launch_command', ' '.join([command, arguments]))
 
+    @Slot(Qt.CheckState)
+    def _lgd_wrapper_check_changed(self, state: Qt.CheckState):
+        _wrapper = str(wrapper_path())
+        config.adjust_envvar(self.app_name, 'LEGENDARY_WRAPPER_EXE', _wrapper if state == Qt.CheckState.Checked else '')
+        self.environ_changed.emit('LEGENDARY_WRAPPER_EXE')
+
 
 LaunchSettingsType = TypeVar('LaunchSettingsType', bound=LaunchSettingsBase)

rare/models/settings.py

@@ -61,9 +61,7 @@ class Settings(Namespace):
 
     local_shader_cache = Setting(key='local_shader_cache', default=False, dtype=bool)
     create_shortcut = Setting(
-        key='create_shortcut',
-        default=pf.system() == 'Windows' and 'WINEUSERNAME' not in os.environ,
-        dtype=bool
+        key='create_shortcut', default=pf.system() == 'Windows' and 'WINEUSERNAME' not in os.environ, dtype=bool
     )
 
 

rare/shared/rare_core.py

@@ -5,7 +5,6 @@
 from collections.abc import Callable, Iterable, Iterator
 from itertools import chain
 from logging import getLogger
-from typing import Optional
 
 from legendary.lfs.eos import EOSOverlayApp
 from legendary.models.game import Game, SaveGameFile

rare/utils/config_helper.py

@@ -35,10 +35,6 @@ def set_boolean(app_name: str, option: str, value: bool) -> None:
     set_option(app_name, option, str(value).lower())
 
 
-def set_envvar(app_name: str, envvar: str, value: str) -> None:
-    set_option(f'{app_name}.env', envvar, value)
-
-
 def remove_section(app_name: str) -> None:
     return
     # Disabled due to env variables implementation
@@ -55,10 +51,6 @@ def remove_option(app_name: str, option: str) -> None:
     # save_config()
 
 
-def remove_envvar(app_name: str, option: str) -> None:
-    remove_option(f'{app_name}.env', option)
-
-
 def adjust_option(app_name: str, option: str, value: str) -> None:
     if value:
         set_option(app_name, option, value)
@@ -70,6 +62,14 @@ def get_option(app_name: str, option: str, fallback: Any = None) -> str:
     return _config.get(app_name, option, fallback=fallback)
 
 
+def adjust_option_with_global(app_name: str, option: str, value: str) -> None:
+    value = value if value else ''
+    if value == get_option('default', option, ''):
+        remove_option(app_name, option)
+    else:
+        set_option(app_name, option, value)
+
+
 def get_option_with_global(app_name: str, option: str, fallback: Any = None) -> str:
     _option = get_option('default', option, fallback=fallback)
     _option = get_option(app_name, option, fallback=_option)
@@ -80,17 +80,30 @@ def get_boolean(app_name: str, option: str, fallback: bool = False) -> bool:
     return _config.getboolean(app_name, option, fallback=fallback)
 
 
+def set_envvar(app_name: str, envvar: str, value: str) -> None:
+    set_option(f'{app_name}.env', envvar, value)
+
+
+def remove_envvar(app_name: str, option: str) -> None:
+    remove_option(f'{app_name}.env', option)
+
+
 def adjust_envvar(app_name: str, option: str, value: str) -> None:
-    if value:
-        set_envvar(app_name, option, value)
-    else:
-        remove_envvar(app_name, option)
+    adjust_option(f'{app_name}.env', option, value)
 
 
 def get_envvar(app_name: str, option: str, fallback: Any = None) -> str:
     return get_option(f'{app_name}.env', option, fallback=fallback)
 
 
+def adjust_envvar_with_global(app_name: str, option: str, value: str) -> None:
+    value = value if value else ''
+    if value == get_envvar('default', option, ''):
+        remove_envvar(app_name, option)
+    else:
+        set_envvar(app_name, option, value)
+
+
 def get_envvar_with_global(app_name: str, option: str, fallback: Any = None) -> str:
     _option = _config.get('default.env', option, fallback=fallback)
     _option = _config.get(f'{app_name}.env', option, fallback=_option)

rare/utils/workarounds.py

@@ -7,6 +7,7 @@
 
 from rare.utils import config_helper as config
 from rare.utils.paths import data_dir
+from rare.utils.wrapper_exe import wrapper_path
 
 
 class Workarounds:
@@ -70,11 +71,16 @@ def screen_height() -> int:
     def screen_width() -> int:
         return QApplication.instance().primaryScreen().geometry().width()
 
+    @staticmethod
+    def wrapper_exe() -> str:
+        return str(wrapper_path())
+
     @staticmethod
     def subst(text: str) -> str:
         return text.format(
             res_width=Workarounds.screen_width(),
             res_height=Workarounds.screen_height(),
+            wrapper_exe=Workarounds.wrapper_exe(),
         )
 
 

rare/utils/wrapper_exe.py

@@ -23,8 +23,6 @@ def wrapper_path() -> Path:
 
 
 def download_lgd_wrapper() -> bool:
-    config.remove_envvar('default', 'LEGENDARY_WRAPPER_EXE')
-
     runtime_assets = {
         wrapper_path().name: {
             'version': 'v0.0',