diff --git a/app/src/main/java/com/droiddeck/launcher/FrontEndActivity.kt b/app/src/main/java/com/droiddeck/launcher/FrontEndActivity.kt index 1081cb8948..8ff9a1a487 100644 --- a/app/src/main/java/com/droiddeck/launcher/FrontEndActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/FrontEndActivity.kt @@ -120,6 +120,7 @@ class FrontEndActivity : ComponentActivity() { private var glThread by mutableStateOf(true) private var noGlError by mutableStateOf(true) private var returnAfterGame by mutableStateOf(true) + private var shaderPrecache by mutableStateOf(true) private var steamRepairQueued by mutableStateOf(false) private var mangoapp by mutableStateOf(true) private var steamController by mutableStateOf(SessionPrefs.CONTROLLER_DECK) @@ -1634,6 +1635,7 @@ class FrontEndActivity : ComponentActivity() { syncBackend = if (mode == SessionService.MODE_STEAM) SessionPrefs.syncBackendOf(fastSync, fsyncFirst, syncFallback) else null, steamClientArch = if (mode == SessionService.MODE_STEAM) steamClientArch else null, returnAfterGame = if (mode == SessionService.MODE_STEAM) returnAfterGame else null, + shaderPrecache = if (mode == SessionService.MODE_STEAM) shaderPrecache else null, steamRepairQueued = steamRepairQueued, mangoapp = mangoapp, steamController = if (mode == SessionService.MODE_STEAM) steamController else null, @@ -1723,6 +1725,7 @@ class FrontEndActivity : ComponentActivity() { onSteamClientArch = { id -> SessionPrefs.setSteamClientArch(this, id); steamClientArch = id; refresh() }, onMangoapp = { on -> SessionPrefs.setMangoapp(this, on); mangoapp = on }, onReturnAfterGame = { on -> SessionPrefs.setReturnAfterGame(this, on); returnAfterGame = on }, + onShaderPrecache = { on -> SessionPrefs.setShaderPrecache(this, on); shaderPrecache = on }, onSteamController = { id -> SessionPrefs.setSteamController(this, id); steamController = id }, onRunSteamAtStartup = { on -> SessionPrefs.setRunSteamAtStartup(this, on) @@ -1892,6 +1895,7 @@ class FrontEndActivity : ComponentActivity() { steamRepairQueued = SteamRepair.queued(this) mangoapp = SessionPrefs.mangoapp(this) returnAfterGame = SessionPrefs.returnAfterGame(this) + shaderPrecache = SessionPrefs.shaderPrecache(this) steamController = SessionPrefs.steamController(this) runSteamAtStartup = SessionPrefs.runSteamAtStartup(this) loadBootMovie() diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt index 47ffb2c934..4824a44424 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt @@ -58,6 +58,7 @@ object SessionFiles { "usr/local/bin/droiddeck-steam-install" to "usr/local/bin/droiddeck-steam-install", "usr/local/bin/droiddeck-steam-ui-scale" to "usr/local/bin/droiddeck-steam-ui-scale", "usr/local/bin/droiddeck-steam-language" to "usr/local/bin/droiddeck-steam-language", + "usr/local/bin/droiddeck-steam-shaders" to "usr/local/bin/droiddeck-steam-shaders", "usr/local/bin/droiddeck-steam-desktop-ui" to "usr/local/bin/droiddeck-steam-desktop-ui", "usr/local/bin/droiddeck-steam-library" to "usr/local/bin/droiddeck-steam-library", "usr/local/bin/droiddeck-seed-redists" to "usr/local/bin/droiddeck-seed-redists", diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt index f28c687342..057f870708 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionPrefs.kt @@ -304,6 +304,24 @@ object SessionPrefs { prefs(context).edit().putBoolean("returnAfterGame", on).apply() } + /** + * Shader pre-caching as the launcher last set it, until the next session writes it into the + * client's config.vdf; after that the client's own toggle is the user's again. + */ + fun pendingShaderPrecache(context: Context): Boolean? = + prefs(context).takeIf { it.contains("shaderPrecache") }?.getBoolean("shaderPrecache", true) + + fun setShaderPrecache(context: Context, on: Boolean) { + prefs(context).edit().putBoolean("shaderPrecache", on).apply() + } + + fun takeShaderPrecache(context: Context): Boolean? = + pendingShaderPrecache(context)?.also { prefs(context).edit().remove("shaderPrecache").apply() } + + fun shaderPrecache(context: Context): Boolean = pendingShaderPrecache(context) + ?: runCatching { com.droiddeck.launcher.storage.SteamStorage.shaderPrecache( + java.io.File(steamRoot(context, steamClientArch(context)), "config/config.vdf").readText()) }.getOrDefault(true) + fun stretch16x9(context: Context): Boolean = prefs(context).getBoolean("stretch16x9", false) fun setStretch16x9(context: Context, on: Boolean) { diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt index 3db04cabc7..253b0fa301 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt @@ -673,6 +673,7 @@ class SessionService : Service() { com.droiddeck.launcher.core.AppLanguage.system(this).country, )) guest.add("TZ=" + java.util.TimeZone.getDefault().id) + if (SessionState.mode == MODE_STEAM) SessionPrefs.takeShaderPrecache(this)?.let { guest.add("BL_SHADER_PRECACHE=" + if (it) "1" else "0") } guest.add("XDG_RUNTIME_DIR=" + LinuxRuntime.GUEST_RUNTIME_DIR) guest.add("XDG_SESSION_TYPE=wayland") guest.add("WAYLAND_DISPLAY=wayland-0") diff --git a/app/src/main/java/com/droiddeck/launcher/storage/SteamStorage.kt b/app/src/main/java/com/droiddeck/launcher/storage/SteamStorage.kt index e707fd59fc..7fecd5aba1 100644 --- a/app/src/main/java/com/droiddeck/launcher/storage/SteamStorage.kt +++ b/app/src/main/java/com/droiddeck/launcher/storage/SteamStorage.kt @@ -28,6 +28,7 @@ object SteamStorage { private val LAST_PLAYED = Regex("^\\s*\"LastPlayed\"\\s*\"(\\d+)\"", RegexOption.MULTILINE) private val MAPPING = Regex("\"(\\d+)\"\\s*\\{\\s*\"name\"\\s*\"([^\"]*)\"") private val COMPAT_NAME = Regex("\"compat_tools\"\\s*\\{\\s*\"([^\"]+)\"") + private val SHADER_CACHE_OFF = Regex("\"DisableShaderCache\"\\s*\"1\"", RegexOption.IGNORE_CASE) data class Manifest( val file: File, val appId: Int, val name: String, val installDir: String?, @@ -118,6 +119,8 @@ object SteamStorage { return MAPPING.findAll(configVdf.substring(open, end)).associate { it.groupValues[1] to it.groupValues[2] } } + fun shaderPrecache(configVdf: String): Boolean = !SHADER_CACHE_OFF.containsMatchIn(configVdf) + fun compatToolName(compatibilityToolVdf: String): String? = COMPAT_NAME.find(compatibilityToolVdf)?.groupValues?.get(1) private val ARM_IN_NAME = Regex("arm64|aarch64") diff --git a/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt b/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt index a444f37115..c546a34c35 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt @@ -82,6 +82,8 @@ class ModeSettings( val steamClientArch: String? = null, /** Steam only: a game launched from the front end returns there when it closes; null hides the row. */ val returnAfterGame: Boolean? = null, + /** Steam only: the client's Shader Pre-Caching setting; null hides the row. */ + val shaderPrecache: Boolean? = null, val steamRepairQueued: Boolean = false, val mangoapp: Boolean = true, val steamController: String? = null, @@ -136,6 +138,7 @@ class ModeSettingsActions( val onSteamClientArch: (String) -> Unit = {}, val onMangoapp: (Boolean) -> Unit = {}, val onReturnAfterGame: (Boolean) -> Unit = {}, + val onShaderPrecache: (Boolean) -> Unit = {}, val onSteamController: (String) -> Unit = {}, val onUnfoldedControls: (Boolean) -> Unit = {}, val onUnfoldedControlsWithController: (Boolean) -> Unit = {}, @@ -478,6 +481,11 @@ fun ModeSheetRows(s: ModeSettings, a: ModeSettingsActions, tab: String, extras: stringResource(R.string.mode_return_after_game_hint), s.returnAfterGame, onChange = a.onReturnAfterGame, ) + if (s.shaderPrecache != null) ToggleRow( + host, "shaderprecache", stringResource(R.string.mode_shader_precache), + stringResource(R.string.mode_shader_precache_hint), + s.shaderPrecache, onChange = a.onShaderPrecache, + ) SettingsRow( stringResource(R.string.mode_steam_repair), stringResource(if (s.steamRepairQueued) R.string.mode_steam_repair_queued else R.string.mode_steam_repair_hint), diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index e62952c4f7..6986345870 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -320,6 +320,8 @@ Turn off if games crash or go black in Deck mode. Applies next session. Return to DroidDeck after a game When a game you started from DroidDeck or another launcher closes, Steam exits cleanly (cloud saves finish first) and you go back there. Off: stay in Steam. + Shader pre-caching + Steam downloads shaders prebuilt for your games and processes them in the background, so games stutter less. Off saves data, storage and battery; games build shaders as they play instead. The same setting as Steam’s Downloads > Shader Pre-Caching. Applies next session. Repair Steam client Downloads the Steam client again the next time Steam starts. Use it if Steam stays on its loading screen. Games, sign-in and settings are kept. The Steam client will be downloaded again the next time Steam starts. diff --git a/app/src/test/java/com/droiddeck/launcher/storage/SteamStorageTest.kt b/app/src/test/java/com/droiddeck/launcher/storage/SteamStorageTest.kt index 794e01d44d..6041c7591f 100644 --- a/app/src/test/java/com/droiddeck/launcher/storage/SteamStorageTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/storage/SteamStorageTest.kt @@ -92,6 +92,22 @@ class SteamStorageTest { assertEquals(emptyMap(), SteamStorage.compatMappings("\"x\" {}")) } + @Test fun readsShaderPrecacheFromConfig() { + val vdf = """ + "InstallConfigStore" + { + "Software" { "Valve" { "Steam" { "ShaderCacheManager" + { + "HasCurrentBucket" "1" + "DisableShaderCache" "1" + } } } } + } + """.trimIndent() + assertEquals(false, SteamStorage.shaderPrecache(vdf)) + assertEquals(true, SteamStorage.shaderPrecache(vdf.replace("\"DisableShaderCache\"\t\t\"1\"", "\"DisableShaderCache\"\t\t\"0\""))) + assertEquals(true, SteamStorage.shaderPrecache("\"InstallConfigStore\" {}")) + } + @Test fun readsCustomToolName() { val vdf = "\"compatibilitytools\"\n{\n \"compat_tools\"\n {\n \"GE-Proton11-9-aarch64\"\n {\n \"install_path\" \".\"\n }\n }\n}" assertEquals("GE-Proton11-9-aarch64", SteamStorage.compatToolName(vdf)) diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-session b/tools/linuxfs/overlay/usr/local/bin/droiddeck-session index c33b785524..809b5d4da2 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-session +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-session @@ -531,6 +531,10 @@ case $mode in fi droiddeck-seed-redists "$steam_root" || true fi + if [ -n "${BL_SHADER_PRECACHE:-}" ]; then + droiddeck-steam-shaders "$BL_SHADER_PRECACHE" "$XDG_DATA_HOME/Steam" \ + "${BL_X64_HOME:-$HOME/.droiddeck-x64}/.local/share/Steam" || true + fi if [ "$steam_x64" = 0 ] && [ ! -f "$steam_root/steamapps/appmanifest_4427310.acf" ]; then step "asking the client to fetch the ARM64 Proton" set -- "$@" steam://install/4427310 diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-shaders b/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-shaders new file mode 100755 index 0000000000..da93ebec4c --- /dev/null +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-shaders @@ -0,0 +1,61 @@ +#!/usr/bin/python3 +"""Sets the Steam client's shader pre-caching (Settings > Downloads), before the client starts. + + droiddeck-steam-shaders <0|1> ... + +The client stores the toggle as InstallConfigStore/Software/Valve/Steam/ShaderCacheManager/ +DisableShaderCache in config/config.vdf: "1" when off, "0" when on. It keeps the setting in memory +and writes config.vdf back on exit, so this runs only while the client is stopped. The launcher +passes a value only after its own toggle changes; otherwise the client's toggle stays the user's.""" +from pathlib import Path +import runpy +import sys + + +VDF = runpy.run_path(str(Path(__file__).with_name("droiddeck-steam-ui-scale"))) +PATH = ("Software", "Valve", "Steam", "ShaderCacheManager", "DisableShaderCache") + + +def set_text(text, enabled): + value = "0" if enabled else "1" + updated, changed = VDF["seed_value"](text, PATH, value) + if changed: + return updated, True + block = VDF["parse"](text).get("InstallConfigStore") + for section in PATH[:-1]: + block = block.get(section) + current = block.get(PATH[-1]) + if isinstance(current, VDF["Block"]): + raise ValueError("invalid DisableShaderCache setting") + if current == value: + return text, False + at = block.offset(PATH[-1]) + end = VDF["TOKEN"].match(text, at).end() + return text[:at] + f'"{value}"' + text[end:], True + + +def apply(steam_root, enabled): + config = Path(steam_root) / "config/config.vdf" + text = config.read_text() if config.exists() else '"InstallConfigStore"\n{\n}\n' + updated, changed = set_text(text, enabled) + if changed: + VDF["atomic_write"](config, updated) + return changed + + +if __name__ == "__main__": + if len(sys.argv) < 3 or sys.argv[1] not in ("0", "1"): + print("usage: droiddeck-steam-shaders <0|1> ...", file=sys.stderr) + sys.exit(2) + enabled = sys.argv[1] == "1" + status = 0 + for root in sys.argv[2:]: + if not Path(root).is_dir(): + continue + try: + if apply(root, enabled): + print(f"== steam: shader pre-caching {'on' if enabled else 'off'} in {root}") + except (OSError, ValueError, RecursionError) as error: + print(f"== steam: left shader pre-caching unchanged in {root}: {error}", file=sys.stderr) + status = 1 + sys.exit(status) diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-ui-scale b/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-ui-scale index 4a59976842..af809d1245 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-ui-scale +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-ui-scale @@ -26,9 +26,10 @@ TOKEN = re.compile(r'\s+|//[^\n]*|"(?:\\.|[^"\\])*"|[{}]') class Block: - def __init__(self, pairs, end): + def __init__(self, pairs, end, offsets=()): self.pairs = pairs self.end = end + self.offsets = offsets def get(self, name): matches = [value for key, value in self.pairs if key.lower() == name.lower()] @@ -36,6 +37,9 @@ class Block: raise ValueError("duplicate UI setting") return matches[0] if matches else None + def offset(self, name): + return next(at for (key, _), at in zip(self.pairs, self.offsets) if key.lower() == name.lower()) + def parse(text): tokens = [] @@ -51,17 +55,17 @@ def parse(text): raise ValueError("invalid config.vdf") def block(index, nested=False): - pairs = [] + pairs, offsets = [], [] while index < len(tokens): token, offset = tokens[index] if token == '}': if not nested: raise ValueError("unexpected closing brace") - return Block(pairs, offset), index + 1 + return Block(pairs, offset, offsets), index + 1 if not token.startswith('"') or index + 1 == len(tokens): raise ValueError("missing config value") key = token[1:-1] - value = tokens[index + 1][0] + value, at = tokens[index + 1] index += 2 if value == '{': value, index = block(index, True) @@ -70,9 +74,10 @@ def parse(text): else: raise ValueError("invalid config value") pairs.append((key, value)) + offsets.append(at) if nested: raise ValueError("unclosed config block") - return Block(pairs, len(text)), index + return Block(pairs, len(text), offsets), index return block(0)[0] diff --git a/tools/tests/test_steam_shaders.py b/tools/tests/test_steam_shaders.py new file mode 100644 index 0000000000..1d273215a3 --- /dev/null +++ b/tools/tests/test_steam_shaders.py @@ -0,0 +1,88 @@ +from pathlib import Path +import runpy +import tempfile +import unittest + + +BIN = Path(__file__).resolve().parents[1] / 'linuxfs/overlay/usr/local/bin' +MODULE = runpy.run_path(str(BIN / 'droiddeck-steam-shaders')) +apply = MODULE['apply'] +set_text = MODULE['set_text'] +parse = runpy.run_path(str(BIN / 'droiddeck-steam-ui-scale'))['parse'] + +THOR = '''"InstallConfigStore" +{ +\t"Software" +\t{ +\t\t"Valve" +\t\t{ +\t\t\t"Steam" +\t\t\t{ +\t\t\t\t"ShaderCacheManager" +\t\t\t\t{ +\t\t\t\t\t"HasCurrentBucket"\t\t"1" +\t\t\t\t\t"ProcessingQueue"\t\t"207140;848350;" +\t\t\t\t\t"App" +\t\t\t\t\t{ +\t\t\t\t\t} +\t\t\t\t} +\t\t\t} +\t\t} +\t} +} +''' + + +def disabled(text): + steam = parse(text).get('InstallConfigStore').get('Software').get('Valve').get('Steam') + return steam.get('ShaderCacheManager').get('DisableShaderCache') + + +class SteamShadersTest(unittest.TestCase): + def setUp(self): + self.temp = tempfile.TemporaryDirectory() + self.addCleanup(self.temp.cleanup) + self.root = Path(self.temp.name) + self.config = self.root / 'config/config.vdf' + self.config.parent.mkdir() + + def test_off_adds_the_key_the_client_writes(self): + text, changed = set_text(THOR, False) + self.assertTrue(changed) + self.assertEqual('1', disabled(text)) + self.assertIn('\t\t\t\t\t"DisableShaderCache"\t\t"1"\n\t\t\t\t}', text) + self.assertIn('"ProcessingQueue"\t\t"207140;848350;"', text) + + def test_existing_value_is_replaced_in_place(self): + off, _ = set_text(THOR, False) + on, changed = set_text(off, True) + self.assertTrue(changed) + self.assertEqual('0', disabled(on)) + self.assertEqual(off.replace('"DisableShaderCache"\t\t"1"', '"DisableShaderCache"\t\t"0"'), on) + + def test_matching_value_leaves_the_file_alone(self): + off, _ = set_text(THOR, False) + self.assertEqual((off, False), set_text(off, False)) + + def test_missing_sections_are_created(self): + text, changed = set_text('"InstallConfigStore"\n{\n}\n', False) + self.assertTrue(changed) + self.assertEqual('1', disabled(text)) + + def test_apply_writes_config_and_creates_a_fresh_one(self): + self.config.write_text(THOR) + self.assertTrue(apply(self.root, False)) + self.assertEqual('1', disabled(self.config.read_text())) + self.assertFalse(apply(self.root, False)) + fresh = Path(self.temp.name) / 'fresh' + fresh.mkdir() + self.assertTrue(apply(fresh, True)) + self.assertEqual('0', disabled((fresh / 'config/config.vdf').read_text())) + + def test_invalid_config_is_rejected(self): + with self.assertRaises(ValueError): + set_text('"InstallConfigStore" {', False) + + +if __name__ == '__main__': + unittest.main()