mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-21 05:46:03 +00:00
The session's TU_DEBUG=sysmem is meant for the Steam client and Chromium-based apps. Flatpak and Snap apps inherited it, so emulators and other programs installed that way rendered through system memory. droiddeck-game-env now holds the Chromium check next to game_gpu, and a small droiddeck-game-gpu wrapper applies both to any program. The AppImage, Flatpak and Snap launchers use it, so the rule lives in one place.
1301 lines
50 KiB
Python
Executable File
1301 lines
50 KiB
Python
Executable File
#!/usr/bin/python3
|
|
import hashlib
|
|
import json
|
|
import os
|
|
import re
|
|
import runpy
|
|
import signal
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
from pathlib import Path
|
|
|
|
GAME_TU_DEBUG = "DROIDDECK_GAME_TU_DEBUG"
|
|
CHROMIUM_FILES = {"chrome-sandbox", "chrome_100_percent.pak", "v8_context_snapshot.bin"}
|
|
SYNC_KEYS = ("BL_SYNC", "BL_SYNC_FALLBACK", "BL_FSYNC_FIRST", "BL_SYNC_MIN_NOFILE", "PROTON_NO_ESYNC", "PROTON_NO_FSYNC", "PROTON_NO_NTSYNC", "WINEESYNC")
|
|
SEED_REDISTS = "/usr/local/bin/droiddeck-seed-redists"
|
|
PACK_KEYS = ("WINESERVER", "BL_SYNC_PACK", "WINEESYNC", "PROTON_NO_ESYNC", "PROTON_NO_FSYNC")
|
|
|
|
|
|
def game_id(env):
|
|
prefix = env.get("STEAM_COMPAT_DATA_PATH", "").rstrip("/")
|
|
if not prefix:
|
|
return None
|
|
value = prefix.rsplit("/", 1)[-1]
|
|
if not re.fullmatch(r"-?[0-9]+", value):
|
|
return None
|
|
number = int(value)
|
|
if not -(2**31) <= number < 2**32 or number == 0:
|
|
return None
|
|
return str(number % 2**32)
|
|
|
|
|
|
DOTNET_FEX = {
|
|
"FEX_TSOENABLED": "1",
|
|
"FEX_VECTORTSOENABLED": "1",
|
|
"FEX_MEMCPYSETTSOENABLED": "1",
|
|
"FEX_HALFBARRIERTSOENABLED": "1",
|
|
"FEX_X87REDUCEDPRECISION": "0",
|
|
}
|
|
|
|
|
|
def game_files(exe):
|
|
names = set()
|
|
folder = os.path.dirname(exe)
|
|
try:
|
|
with os.scandir(folder) as top:
|
|
for entry in top:
|
|
names.add(entry.name.lower())
|
|
if entry.is_dir(follow_symlinks=False):
|
|
try:
|
|
with os.scandir(entry.path) as inner:
|
|
names.update(e.name.lower() for e in inner)
|
|
except OSError:
|
|
pass
|
|
except OSError:
|
|
pass
|
|
return names
|
|
|
|
|
|
class Game:
|
|
|
|
def __init__(self, exe, args):
|
|
self.exe = exe
|
|
self.args = args
|
|
self.stem = os.path.splitext(os.path.basename(exe))[0].lower()
|
|
self.files = game_files(exe)
|
|
|
|
def has_arg(self, name):
|
|
return any(a == name or a.startswith(name + "=") for a in self.args)
|
|
|
|
|
|
FIXES = []
|
|
|
|
|
|
def fix(function):
|
|
FIXES.append(function)
|
|
return function
|
|
|
|
|
|
def is_godot(game):
|
|
return game.stem + ".pck" in game.files or "godotsharp.dll" in game.files
|
|
|
|
|
|
@fix
|
|
def dotnet_memory_ordering(game):
|
|
if "coreclr.dll" in game.files:
|
|
return DOTNET_FEX, [], ".NET runtime: FEX with full TSO"
|
|
|
|
|
|
@fix
|
|
def unity_memory_ordering(game):
|
|
if {"unityplayer.so", "gameassembly.so", "unityplayer.dll"} & game.files:
|
|
return {"FEX_TSOENABLED": "1"}, [], "Unity: FEX with TSO"
|
|
|
|
|
|
@fix
|
|
def godot_vulkan(game):
|
|
if is_godot(game) and not game.has_arg("--rendering-driver"):
|
|
return {}, ["--rendering-driver", "vulkan"], "Godot: Vulkan renderer"
|
|
|
|
|
|
@fix
|
|
def godot_sentry(game):
|
|
sentry = sorted(n[:-4] for n in game.files if n.startswith("libsentry.windows.") and n.endswith(".dll"))
|
|
if is_godot(game) and sentry and ("coreclr.dll" in game.files or "godotsharp.dll" in game.files):
|
|
return {"WINEDLLOVERRIDES": ";".join(n + "=d" for n in sentry)}, [], "Godot: Sentry crash handler off"
|
|
|
|
|
|
@fix
|
|
def d3dgear_hook(game):
|
|
if "d3dgear64.dll" in game.files:
|
|
return {"WINEDLLOVERRIDES": "d3dgear64=d"}, [], "D3DGear capture hook off (it stops the game drawing)"
|
|
|
|
|
|
@fix
|
|
def supergiant_dotnet_reporter(game):
|
|
if "basecampbugreporter.native.dll" in game.files:
|
|
return {"WINEDLLOVERRIDES": "mscoree=n,b"}, [], "Supergiant: allow the builtin mscoree"
|
|
|
|
|
|
@fix
|
|
def deep_rock_gdk_raytracing(game):
|
|
if game.stem == "fsd-wingdk-shipping" and not any(game.has_arg(arg) for arg in ("-raytracing", "-noraytracing")):
|
|
return {}, ["-noraytracing", "-ini:Engine:[/Script/Engine.RendererSettings]:r.RayTracing=False"], "Deep Rock Galactic GDK: ray tracing off (D3D12 pipeline creation fails on Thor)"
|
|
|
|
|
|
@fix
|
|
def arkham_city_x87(game):
|
|
if "batmanac.exe" in game.files:
|
|
return {"FEX_X87REDUCEDPRECISION": "0"}, [], "Batman: Arkham City: FEX with full x87 precision"
|
|
|
|
|
|
|
|
@fix
|
|
def doom_2016_swapchain_images(game):
|
|
if "doomx64vk.exe" in game.files and game.stem in ("doomx64", "doomx64vk"):
|
|
images = {
|
|
"GAMESCOPE_WSI_MIN_IMAGE_COUNT": None,
|
|
"GAMESCOPE_WSI_ENSURE_MIN_IMAGE_COUNT": None,
|
|
"vk_x11_strict_image_count": "true",
|
|
}
|
|
return images, [], "DOOM (2016): the swapchain keeps the image count the game asks for"
|
|
|
|
|
|
@fix
|
|
def teardown_vsync(game):
|
|
if game.stem == "teardown":
|
|
return {"vblank_mode": "2"}, [], "Teardown: OpenGL keeps the game's own vsync"
|
|
|
|
|
|
@fix
|
|
def protonfixes_off(game):
|
|
if game.stem in ("blackops3", "darksoulsremastered"):
|
|
return {"PROTONFIXES_DISABLE": "1"}, [], "umu-protonfixes off (its ALSA audio and VC++ installer steps fail here)"
|
|
|
|
|
|
@fix
|
|
def little_nightmares_threads(game):
|
|
if game.stem == "littlenightmares":
|
|
return {"PROTONFIXES_DISABLE": "1"}, [], "Little Nightmares: umu-protonfixes off (its -onethread puts the game and renderer on one thread)"
|
|
|
|
|
|
def skip_red_launcher(command):
|
|
if len(command) > 2 and os.path.basename(command[2]).lower() == "redprelauncher.exe":
|
|
game = os.path.join(os.path.dirname(command[2]), "bin", "x64", "Cyberpunk2077.exe")
|
|
if os.path.isfile(game):
|
|
print("droiddeck-game-env: REDlauncher skipped", file=sys.stderr)
|
|
return command[:2] + [game] + command[3:]
|
|
return command
|
|
|
|
|
|
UBISOFT_LAUNCHER = "drive_c/Program Files (x86)/Ubisoft/Ubisoft Game Launcher"
|
|
UBISOFT_SETTINGS = "drive_c/users/steamuser/AppData/Local/Ubisoft Game Launcher/settings.yaml"
|
|
|
|
|
|
def overlay_off(text):
|
|
lines = text.splitlines()
|
|
try:
|
|
start = next(i for i, line in enumerate(lines) if re.fullmatch(r"overlay:\s*(#.*)?", line))
|
|
except StopIteration:
|
|
if lines and not lines[-1].strip():
|
|
lines.pop()
|
|
return "\n".join(lines + ["overlay:", " enabled: false", " warning_enabled: false"]) + "\n"
|
|
end = start + 1
|
|
for index in range(start + 1, len(lines)):
|
|
if lines[index].strip() and not lines[index].startswith(" "):
|
|
break
|
|
if lines[index].strip():
|
|
end = index + 1
|
|
block = lines[start + 1:end]
|
|
for key in ("enabled", "warning_enabled"):
|
|
entry = " %s: false" % key
|
|
found = [i for i, line in enumerate(block) if line.split(":", 1)[0] == " " + key]
|
|
if found:
|
|
block[found[0]] = entry
|
|
else:
|
|
block.append(entry)
|
|
return "\n".join(lines[:start + 1] + block + lines[end:]) + "\n"
|
|
|
|
|
|
def ubisoft_overlay_off(env):
|
|
prefix = Path(env.get("STEAM_COMPAT_DATA_PATH", "/nonexistent")) / "pfx"
|
|
if not (prefix / UBISOFT_LAUNCHER).is_dir():
|
|
return
|
|
settings = prefix / UBISOFT_SETTINGS
|
|
try:
|
|
text = settings.read_text(encoding="utf-8") if settings.exists() else ""
|
|
updated = overlay_off(text)
|
|
if updated == text:
|
|
return
|
|
settings.parent.mkdir(parents=True, exist_ok=True)
|
|
handle, staged = tempfile.mkstemp(prefix=".settings-", dir=settings.parent)
|
|
try:
|
|
with os.fdopen(handle, "w", encoding="utf-8") as target:
|
|
target.write(updated)
|
|
if settings.exists():
|
|
os.chmod(staged, settings.stat().st_mode & 0o7777)
|
|
os.replace(staged, settings)
|
|
except BaseException:
|
|
os.unlink(staged)
|
|
raise
|
|
print("droiddeck-game-env: Ubisoft Connect overlay turned off", file=sys.stderr)
|
|
except (OSError, UnicodeDecodeError) as error:
|
|
print("droiddeck-game-env: Ubisoft Connect overlay left as is (%s)" % error, file=sys.stderr)
|
|
|
|
|
|
def ubisoft_composition_off(proton, env):
|
|
prefix = Path(env.get("STEAM_COMPAT_DATA_PATH", "/nonexistent")) / "pfx"
|
|
if not (prefix / UBISOFT_LAUNCHER).is_dir() or not (prefix / "user.reg").is_file():
|
|
return
|
|
try:
|
|
for program in ("upc.exe", "UplayWebCore.exe"):
|
|
key = r"HKCU\Software\Wine\AppDefaults\%s\DllOverrides" % program
|
|
subprocess.run([proton, "runinprefix", "reg.exe", "add", key,
|
|
"/v", "dcomp", "/t", "REG_SZ", "/d", "", "/f"], env=env, check=True)
|
|
print("droiddeck-game-env: Ubisoft Connect uses CEF without DirectComposition", file=sys.stderr)
|
|
except (OSError, ValueError, subprocess.CalledProcessError) as error:
|
|
print("droiddeck-game-env: Ubisoft Connect composition configuration failed (%s)" % error, file=sys.stderr)
|
|
|
|
|
|
PZ_JVM_FLAGS = ("-XX:+UseG1GC", "-XX:TieredStopAtLevel=1")
|
|
|
|
|
|
def zomboid_vm_args(args):
|
|
updated = [arg for arg in args if not re.fullmatch(r"-XX:\+Use\w*GC", arg) or arg == "-XX:+UseG1GC"]
|
|
for flag in PZ_JVM_FLAGS:
|
|
if flag not in updated:
|
|
updated.append(flag)
|
|
return updated
|
|
|
|
|
|
def zomboid_rewrite(node):
|
|
changed = False
|
|
if isinstance(node, dict):
|
|
for key, value in node.items():
|
|
if key == "vmArgs" and isinstance(value, list) and all(isinstance(arg, str) for arg in value):
|
|
updated = zomboid_vm_args(value)
|
|
if updated != value:
|
|
node[key] = updated
|
|
changed = True
|
|
elif isinstance(value, dict):
|
|
changed |= zomboid_rewrite(value)
|
|
return changed
|
|
|
|
|
|
def project_zomboid_jvm(command):
|
|
if len(command) <= 2:
|
|
return
|
|
exe = Path(command[2])
|
|
if not exe.stem.lower().startswith("projectzomboid"):
|
|
return
|
|
settings = exe.with_suffix(".json")
|
|
try:
|
|
with settings.open(encoding="utf-8-sig") as source:
|
|
data = json.load(source)
|
|
if not zomboid_rewrite(data):
|
|
return
|
|
handle, staged = tempfile.mkstemp(prefix=".droiddeck-", dir=settings.parent)
|
|
try:
|
|
with os.fdopen(handle, "w", encoding="utf-8") as target:
|
|
json.dump(data, target, indent=4)
|
|
target.write("\n")
|
|
os.chmod(staged, settings.stat().st_mode & 0o7777)
|
|
os.replace(staged, settings)
|
|
except BaseException:
|
|
os.unlink(staged)
|
|
raise
|
|
print("droiddeck-game-env: Project Zomboid: G1 garbage collector and C1 JIT only (ZGC overheats and stalls here)",
|
|
file=sys.stderr)
|
|
except (OSError, ValueError, AttributeError) as error:
|
|
print("droiddeck-game-env: Project Zomboid JVM settings left as is (%s)" % error, file=sys.stderr)
|
|
|
|
|
|
def offline_without_anticheat(command, env):
|
|
if (env.get("DROIDDECK_ANTICHEAT_OFFLINE") != "1" or len(command) <= 2
|
|
or command[1] != "waitforexitandrun"
|
|
or not re.fullmatch(r"start_protected_game(?:_?x64|_?64)?\.exe",
|
|
os.path.basename(command[2]), re.IGNORECASE)):
|
|
return command
|
|
folder = os.path.dirname(command[2])
|
|
try:
|
|
with open(os.path.join(folder, "EasyAntiCheat", "settings.json"), encoding="utf-8-sig") as source:
|
|
executable = json.load(source).get("executable")
|
|
except (OSError, ValueError, AttributeError):
|
|
return command
|
|
if not isinstance(executable, str) or not executable:
|
|
return command
|
|
relative = os.path.normpath(executable.replace("\\", "/"))
|
|
game = os.path.join(folder, relative)
|
|
if os.path.isabs(relative) or relative.startswith("..") or not os.path.isfile(game):
|
|
return command
|
|
root = os.path.realpath(folder)
|
|
if os.path.commonpath((root, os.path.realpath(game))) != root:
|
|
return command
|
|
if os.path.normcase(os.path.abspath(game)) == os.path.normcase(os.path.abspath(command[2])):
|
|
return command
|
|
print("droiddeck-game-env: started without Easy Anti-Cheat (offline only)", file=sys.stderr)
|
|
return command[:2] + [game] + command[3:]
|
|
|
|
|
|
def engine_fixes(exe, args):
|
|
game = Game(exe, args)
|
|
env, extra, notes = {}, [], []
|
|
for check in FIXES:
|
|
found = check(game)
|
|
if found:
|
|
for name, value in found[0].items():
|
|
if name == "WINEDLLOVERRIDES" and env.get(name):
|
|
value = env[name] + ";" + value
|
|
env[name] = value
|
|
extra += found[1]
|
|
notes.append(found[2])
|
|
return env, extra, notes
|
|
|
|
|
|
def win_components(compat, app_id):
|
|
if not compat:
|
|
return ""
|
|
try:
|
|
module = runpy.run_path(str(Path(__file__).resolve().parent / "droiddeck-wincomponents"))
|
|
names, notes = module["apply"](compat.rstrip("/"), app_id)
|
|
for note in notes:
|
|
print("droiddeck-game-env: " + note, file=sys.stderr)
|
|
return module["overrides_value"](names)
|
|
except Exception as error:
|
|
print("droiddeck-game-env: Windows components not applied (%s)" % error, file=sys.stderr)
|
|
return ""
|
|
|
|
|
|
def chromium_app(folder):
|
|
root = os.path.realpath(folder)
|
|
for top, dirs, files in os.walk(root):
|
|
if CHROMIUM_FILES.intersection(files) or CHROMIUM_FILES.intersection(dirs):
|
|
return True
|
|
if os.path.relpath(top, root).count(os.sep) >= 2:
|
|
dirs[:] = []
|
|
return False
|
|
|
|
|
|
def game_gpu(env, keep=False):
|
|
if GAME_TU_DEBUG not in env:
|
|
return env
|
|
result = env.copy()
|
|
value = result.pop(GAME_TU_DEBUG)
|
|
if keep:
|
|
return result
|
|
if value:
|
|
result["TU_DEBUG"] = value
|
|
else:
|
|
result.pop("TU_DEBUG", None)
|
|
return result
|
|
|
|
|
|
def vram_cap(env):
|
|
value = env.get("BL_VRAM_MB", "")
|
|
if not re.fullmatch(r"[1-9][0-9]{0,6}", value):
|
|
return env
|
|
result = env.copy()
|
|
cap = "dxgi.maxDeviceMemory = %d" % int(value)
|
|
own = result.get("DXVK_CONFIG", "").strip().strip(";").strip()
|
|
result["DXVK_CONFIG"] = cap + "; " + own if own else cap
|
|
result["DROIDDECK_VRAM_CAP"] = "1"
|
|
result["DROIDDECK_VRAM_CAP_MB"] = value
|
|
return result
|
|
|
|
|
|
def parse_cores(text):
|
|
cores = set()
|
|
for part in text.replace(" ", "").split(","):
|
|
match = re.fullmatch(r"(\d{1,3})(?:-(\d{1,3}))?", part)
|
|
if not match:
|
|
return None
|
|
first, last = int(match.group(1)), int(match.group(2) or match.group(1))
|
|
if last < first:
|
|
return None
|
|
cores.update(range(first, last + 1))
|
|
return cores or None
|
|
|
|
|
|
def online_cores():
|
|
try:
|
|
with open("/sys/devices/system/cpu/online") as f:
|
|
cores = parse_cores(f.read().strip())
|
|
except OSError:
|
|
cores = None
|
|
return cores or os.sched_getaffinity(0) | set(range(os.cpu_count() or 0))
|
|
|
|
|
|
def game_cores(env):
|
|
text = env.get("DROIDDECK_GAME_CORES", "").strip()
|
|
if not text:
|
|
return
|
|
cores = parse_cores(text)
|
|
chosen = cores & online_cores() if cores else None
|
|
if not chosen:
|
|
print("droiddeck-game-env: ignoring game cores %r" % text, file=sys.stderr)
|
|
return
|
|
try:
|
|
os.sched_setaffinity(0, chosen)
|
|
print("droiddeck-game-env: game cores %s" % ",".join(map(str, sorted(chosen))), file=sys.stderr)
|
|
except OSError as error:
|
|
print("droiddeck-game-env: could not use game cores %r (%s)" % (text, error), file=sys.stderr)
|
|
|
|
|
|
def core_speeds(cores, root="/sys/devices/system/cpu"):
|
|
for name in ("cpu_capacity", "cpufreq/cpuinfo_max_freq"):
|
|
speeds = {}
|
|
for core in cores:
|
|
try:
|
|
with open("%s/cpu%d/%s" % (root, core, name)) as f:
|
|
speeds[core] = int(f.read().strip())
|
|
except (OSError, ValueError):
|
|
break
|
|
else:
|
|
return speeds
|
|
return None
|
|
|
|
|
|
def fastest_first(cores):
|
|
cores = sorted(cores)
|
|
speeds = core_speeds(cores)
|
|
return sorted(cores, key=lambda core: -speeds[core]) if speeds else cores
|
|
|
|
|
|
def proton_cpu_limit(command, env):
|
|
app_id = env.get("SteamGameId", "")
|
|
if not command or not app_id.isdigit():
|
|
return None
|
|
try:
|
|
if os.path.getsize(command[0]) > 4 * 1024 * 1024:
|
|
return None
|
|
with open(command[0], encoding="utf-8", errors="replace") as f:
|
|
text = f.read()
|
|
except OSError:
|
|
return None
|
|
table = re.search(r"^default_cpu_limit = \{(.*?)^\}", text, re.M | re.S)
|
|
match = table and re.search(r'^\s*"%s"\s*:\s*"?(\w+)' % app_id, table.group(1), re.M)
|
|
if not match:
|
|
return None
|
|
value = match.group(1)
|
|
return int(value) if value.isdigit() else value
|
|
|
|
|
|
def cpu_topology(env, command=()):
|
|
if "PROTON_CPU_TOPOLOGY" in env:
|
|
return
|
|
if "WINE_CPU_TOPOLOGY" in env:
|
|
if env["WINE_CPU_TOPOLOGY"]:
|
|
env["PROTON_CPU_TOPOLOGY"] = env["WINE_CPU_TOPOLOGY"]
|
|
return
|
|
picked = bool(env.get("DROIDDECK_GAME_CORES", "").strip() or env.get("BL_GAME_CPUS", "").strip())
|
|
fastest = env.get("DROIDDECK_FASTEST_CORES", "").strip() != "0" and game_id(env) is not None
|
|
if not (picked or fastest):
|
|
return
|
|
try:
|
|
cores = sorted(os.sched_getaffinity(0))
|
|
except OSError:
|
|
return
|
|
online = online_cores()
|
|
if not cores or cores[-1] >= len(online):
|
|
return
|
|
picked = picked and not set(cores) >= online
|
|
if fastest:
|
|
limit = None if picked else proton_cpu_limit(command, env)
|
|
if isinstance(limit, str):
|
|
return
|
|
cores = fastest_first(cores)[:limit or None]
|
|
elif set(cores) >= online:
|
|
return
|
|
if cores == sorted(online):
|
|
return
|
|
env["WINE_CPU_TOPOLOGY"] = env["PROTON_CPU_TOPOLOGY"] = "%d:%s" % (len(cores), ",".join(map(str, cores)))
|
|
print("droiddeck-game-env: Windows sees %d cores (%s)" % (len(cores), env["WINE_CPU_TOPOLOGY"]), file=sys.stderr)
|
|
|
|
|
|
def gl_vsync(env):
|
|
if "vblank_mode" in env or game_id(env) is None:
|
|
return False
|
|
env["vblank_mode"] = "0"
|
|
return True
|
|
|
|
|
|
def game_images(env):
|
|
if game_id(env) is None:
|
|
return False
|
|
env.setdefault("GAMESCOPE_WSI_MIN_IMAGE_COUNT", "8")
|
|
env.setdefault("GAMESCOPE_WSI_ENSURE_MIN_IMAGE_COUNT", "1")
|
|
return True
|
|
|
|
|
|
def apply_config(env, config, app_id, fixes=None):
|
|
if config.get("version") != 1:
|
|
raise ValueError("unsupported environment configuration")
|
|
result = env.copy()
|
|
entries = dict(config.get("shared", {}))
|
|
for name, value in (fixes or {}).items():
|
|
if name == "WINEDLLOVERRIDES" and entries.get(name, env.get(name)):
|
|
value = entries.get(name, env.get(name)) + ";" + value
|
|
entries[name] = value
|
|
entries.update(config.get("games", {}).get(app_id, {}))
|
|
for name, value in entries.items():
|
|
if not re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*", name):
|
|
raise ValueError("invalid environment name")
|
|
if value is None:
|
|
result.pop(name, None)
|
|
elif isinstance(value, str) and "\0" not in value and len(value) <= 8192:
|
|
result[name] = value
|
|
else:
|
|
raise ValueError("invalid environment value")
|
|
game_dxvk = config.get("dxvkConfigGames", {})
|
|
if not isinstance(game_dxvk, dict):
|
|
raise ValueError("invalid game dxvk configuration")
|
|
dxvk = game_dxvk.get(app_id, config.get("dxvkConfig"))
|
|
if dxvk is not None:
|
|
if not isinstance(dxvk, str) or "\0" in dxvk or len(dxvk) > 8192:
|
|
raise ValueError("invalid dxvk configuration")
|
|
if dxvk:
|
|
own = result.get("DXVK_CONFIG", "").strip().rstrip(";").strip()
|
|
result["DXVK_CONFIG"] = own + "; " + dxvk if own else dxvk
|
|
# An open driver pair (PanVK, RADV) on a GPU that is not an Adreno: vkd3d-proton reports the
|
|
# driver's own feature level and shader model. The app-wide 12_2 / 6_9 over-promised what PanVK
|
|
# has, and an Unreal DX12 game took paths that crashed. A game's own setting still wins.
|
|
if env.get("BL_OPEN_DRIVER") == "1":
|
|
game = config.get("games", {}).get(app_id, {}) or {}
|
|
for name in ("VKD3D_FEATURE_LEVEL", "VKD3D_SHADER_MODEL"):
|
|
if name not in game and name in result:
|
|
result.pop(name)
|
|
result["DROIDDECK_VKD3D_CAPS"] = "driver"
|
|
return result
|
|
|
|
|
|
def render_path_defaults(command, env):
|
|
if len(command) < 3 or command[1] != "waitforexitandrun" or Path(command[2]).name.lower() != "spintires.exe":
|
|
return None
|
|
own = env.get("DXVK_CONFIG", "")
|
|
if re.search(r"(?:^|;)\s*dxvk\.tilerMode\s*=", own) or env.get("DXVK_CONFIG_FILE"):
|
|
return None
|
|
if Path("dxvk.conf").is_file() or Path(command[2]).with_name("dxvk.conf").is_file():
|
|
return None
|
|
driver = env.get("VK_DRIVER_FILES", env.get("VK_ICD_FILENAMES", ""))
|
|
if Path(driver).parent.name != "DD-Turnip_v0.4.0":
|
|
return None
|
|
try:
|
|
if Path("/sys/class/kgsl/kgsl-3d0/gpu_model").read_text().strip() != "Adreno722":
|
|
return None
|
|
with open(driver, encoding="utf-8") as source:
|
|
library = json.load(source)["ICD"]["library_path"]
|
|
if Path(library).name != "libvulkan_freedreno.so":
|
|
return None
|
|
except (OSError, ValueError, KeyError, TypeError):
|
|
return None
|
|
own = own.strip().rstrip(";").strip()
|
|
env["DXVK_CONFIG"] = own + "; dxvk.tilerMode = False" if own else "dxvk.tilerMode = False"
|
|
return "Spintires: DXVK tiler heuristics off on Adreno 722"
|
|
|
|
|
|
def bridge_feature_level(env):
|
|
if env.get("BL_VKBRIDGE") != "1" or env.get("VKD3D_FEATURE_LEVEL") not in ("12_1", "12_2"):
|
|
return None
|
|
was = env["VKD3D_FEATURE_LEVEL"]
|
|
env["VKD3D_FEATURE_LEVEL"] = "12_0"
|
|
return "Mali bridge: VKD3D_FEATURE_LEVEL %s capped at 12_0 (no ray tracing or mesh shaders)" % was
|
|
|
|
|
|
GAME_DEBUG_CHANNELS = (
|
|
"timestamp", "pid", "tid", "seh", "unwind", "threadname", "debugstr", "loaddll", "mscoree",
|
|
)
|
|
WINE_DEBUG_SELECTOR = re.compile(r"(?:(trace|warn|err|fixme))?([+-])([A-Za-z_][A-Za-z0-9_]*)")
|
|
|
|
|
|
def game_debug_channels(*values):
|
|
selectors = {}
|
|
for value in values:
|
|
if not isinstance(value, str) or "\0" in value or len(value) > 8192:
|
|
continue
|
|
for part in value.split(","):
|
|
part = part.strip()
|
|
match = WINE_DEBUG_SELECTOR.fullmatch(part)
|
|
if match is None:
|
|
continue
|
|
key = (match[1] or "", match[3])
|
|
selectors.pop(key, None)
|
|
selectors[key] = part
|
|
for channel in GAME_DEBUG_CHANNELS:
|
|
key = ("", channel)
|
|
selectors.pop(key, None)
|
|
selectors[key] = "+" + channel
|
|
formatted = ",".join(selectors.values())
|
|
if len(formatted) > 8192:
|
|
formatted = ",".join("+" + channel for channel in GAME_DEBUG_CHANNELS)
|
|
return formatted
|
|
|
|
|
|
def apply_game_debug_logs(env, config, debug_dir):
|
|
if not isinstance(config, dict) or config.get("version") != 1 or config.get("gameDebugLogs") is not True:
|
|
return env
|
|
if (not isinstance(debug_dir, str) or "\0" in debug_dir or len(debug_dir) > 8192
|
|
or not os.path.isabs(debug_dir) or not os.path.isdir(debug_dir)):
|
|
print("droiddeck-game-env: game debug logs skipped; session log directory unavailable", file=sys.stderr)
|
|
return env
|
|
result = dict(env)
|
|
result.update({
|
|
"PROTON_LOG": "1",
|
|
"PROTON_LOG_DIR": debug_dir,
|
|
"PROTON_CRASH_REPORT_DIR": debug_dir,
|
|
"DXVK_LOG_PATH": debug_dir,
|
|
"DXVK_LOG_LEVEL": "debug",
|
|
"VKD3D_DEBUG": "info",
|
|
"WINEDEBUG": game_debug_channels(env.get("WINEDEBUG"), env.get("PROTON_LOG")),
|
|
})
|
|
return result
|
|
|
|
|
|
def sync_config(config, app_id):
|
|
games = config.get("games", {})
|
|
return {
|
|
"version": config.get("version"),
|
|
"shared": {name: value for name, value in config.get("shared", {}).items() if name in SYNC_KEYS},
|
|
"games": {app_id: {name: value for name, value in games.get(app_id, {}).items() if name in SYNC_KEYS}},
|
|
}
|
|
|
|
|
|
def load_sync():
|
|
try:
|
|
return runpy.run_path(str(Path(__file__).resolve().parent / "droiddeck-esync"))
|
|
except Exception as error:
|
|
print("droiddeck-game-env: sync selection failed (%s); stock launch" % error, file=sys.stderr)
|
|
return None
|
|
|
|
|
|
def select_sync(command, env, sync=None):
|
|
try:
|
|
sync = sync if sync is not None else load_sync()
|
|
if sync is None:
|
|
return command, env
|
|
chosen, chosen_env = sync["select"](command, env)
|
|
if chosen and all(isinstance(value, str) for value in chosen) and isinstance(chosen_env, dict):
|
|
return list(chosen), dict(chosen_env)
|
|
except Exception as error:
|
|
print("droiddeck-game-env: sync selection failed (%s); stock launch" % error, file=sys.stderr)
|
|
return command, env
|
|
|
|
|
|
def record_stock(sync, command, env):
|
|
try:
|
|
if sync is not None and "record" in sync:
|
|
sync["record"](command, env)
|
|
except Exception as error:
|
|
print("droiddeck-game-env: stock launch not recorded (%s)" % error, file=sys.stderr)
|
|
|
|
|
|
def without_pack(chosen_env, env):
|
|
result = dict(chosen_env)
|
|
for name in PACK_KEYS:
|
|
if name in env:
|
|
result[name] = env[name]
|
|
else:
|
|
result.pop(name, None)
|
|
return result
|
|
|
|
|
|
SSBS_LIB = "/usr/local/lib/libssbs.so"
|
|
|
|
|
|
def force_ssbs(command, env):
|
|
if env.get("DROIDDECK_FORCE_SSBS", "").lower() not in ("1", "on", "true", "yes"):
|
|
return env
|
|
proton = os.path.dirname(command[0]) if command else ""
|
|
if not os.path.isdir(os.path.join(proton, "files/lib/wine/aarch64-unix")):
|
|
print("droiddeck-game-env: force SSBS asked for, but this Proton is not an ARM64 one; left off", file=sys.stderr)
|
|
return env
|
|
if not os.path.isfile(SSBS_LIB):
|
|
print("droiddeck-game-env: force SSBS asked for, but %s is missing; left off" % SSBS_LIB, file=sys.stderr)
|
|
return env
|
|
parts = [p for p in re.split(r"[:\s]+", env.get("LD_PRELOAD", "")) if p]
|
|
if SSBS_LIB not in parts:
|
|
env = dict(env, LD_PRELOAD=":".join(parts + [SSBS_LIB]))
|
|
print("droiddeck-game-env: force SSBS on (libssbs.so preloaded)", file=sys.stderr)
|
|
return env
|
|
|
|
|
|
EVALUATOR_SCRIPT = re.compile(r"(?:^|[\\/])evaluatorscript_[0-9]+\.vdf$", re.IGNORECASE)
|
|
|
|
|
|
def mark_install_scripts(command, env):
|
|
if not any(arg.lower().replace("\\", "/").endswith("iscriptevaluator.exe") for arg in command):
|
|
return []
|
|
root = env.get("BL_X64_STEAM_ROOT") or env.get("STEAM_COMPAT_CLIENT_INSTALL_PATH") or str(Path.home() / ".local/share/Steam")
|
|
scripts = [str(Path(root) / arg.replace("\\", "/")) for arg in command if EVALUATOR_SCRIPT.search(arg)]
|
|
scripts = [path for path in scripts if os.path.isfile(path)]
|
|
if not scripts:
|
|
return []
|
|
try:
|
|
subprocess.run([SEED_REDISTS, root], env=dict(env, DROIDDECK_SEED_SCRIPTS="\n".join(scripts)),
|
|
stdout=sys.stderr, timeout=60, check=False)
|
|
except (OSError, subprocess.SubprocessError) as error:
|
|
print("droiddeck-game-env: install scripts not marked (%s)" % error, file=sys.stderr)
|
|
return scripts
|
|
|
|
|
|
INSTALL_STAMP = ".droiddeck-install-scripts"
|
|
VDF_TOKEN = re.compile(r'"((?:[^"\\]|\\.)*)"|([{}])')
|
|
|
|
|
|
def read_vdf(text):
|
|
tokens = iter(VDF_TOKEN.findall(text))
|
|
|
|
def block():
|
|
items = []
|
|
for word, brace in tokens:
|
|
if brace == "}":
|
|
return items
|
|
if brace:
|
|
raise ValueError("a block without a name")
|
|
value, opens = next(tokens, ("", "}"))
|
|
if opens == "}":
|
|
raise ValueError("a name without a value")
|
|
items.append((re.sub(r"\\(.)", r"\1", word), block() if opens else re.sub(r"\\(.)", r"\1", value)))
|
|
return items
|
|
|
|
return block()
|
|
|
|
|
|
def run_keys(items, appid=""):
|
|
appid = next((value for name, value in items if name.lower() == "appid" and isinstance(value, str)), appid)
|
|
found = set()
|
|
for name, value in items:
|
|
if not isinstance(value, list):
|
|
continue
|
|
if any(isinstance(v, str) and re.fullmatch(r"process [0-9]+", n.lower()) for n, v in value):
|
|
key = next((v for n, v in value if n.lower() == "hasrunkey" and isinstance(v, str)),
|
|
"HKEY_LOCAL_MACHINE\\Software\\Valve\\Steam\\Apps\\" + appid)
|
|
found.add((key.lower(), name.lower()))
|
|
found |= run_keys(value, appid)
|
|
return found
|
|
|
|
|
|
def registry_values(path):
|
|
found, section = set(), None
|
|
with open(path, encoding="utf-8", errors="replace") as reg:
|
|
for line in reg:
|
|
if line.startswith("["):
|
|
section = line[1:line.find("]")].replace("\\\\", "\\").lower() if "]" in line else None
|
|
elif section and line.startswith('"') and '"=' in line:
|
|
found.add((section, line[1:line.index('"=')].replace("\\\\", "\\").lower()))
|
|
return found
|
|
|
|
|
|
def has_run(key, value, values):
|
|
path = key[len("hkey_local_machine\\"):] if key.startswith("hkey_local_machine\\") else None
|
|
if path is None:
|
|
return False
|
|
views = [path]
|
|
if path.startswith("software\\"):
|
|
views.append("software\\wow6432node\\" + path[len("software\\"):])
|
|
return any((view, value) in values for view in views)
|
|
|
|
|
|
def scripts_digest(scripts):
|
|
digest = hashlib.sha256()
|
|
for path in sorted(scripts):
|
|
digest.update(os.path.basename(path).encode() + b"\0")
|
|
digest.update(Path(path).read_bytes())
|
|
return digest.hexdigest()
|
|
|
|
|
|
def install_scripts_done(scripts, env):
|
|
prefix = Path(env.get("STEAM_COMPAT_DATA_PATH", "/nonexistent")) / "pfx"
|
|
try:
|
|
if (prefix / INSTALL_STAMP).read_text().strip() != scripts_digest(scripts):
|
|
return False
|
|
keys = set()
|
|
for path in scripts:
|
|
keys |= run_keys(read_vdf(Path(path).read_text(encoding="utf-8", errors="replace")))
|
|
values = registry_values(prefix / "system.reg")
|
|
except (OSError, ValueError):
|
|
return False
|
|
return bool(keys) and all(has_run(key, value, values) for key, value in keys)
|
|
|
|
|
|
def record_install_scripts(digest, env):
|
|
prefix = Path(env.get("STEAM_COMPAT_DATA_PATH", "/nonexistent")) / "pfx"
|
|
try:
|
|
if prefix.is_dir():
|
|
staged = prefix / (INSTALL_STAMP + ".tmp")
|
|
staged.write_text(digest + "\n")
|
|
staged.replace(prefix / INSTALL_STAMP)
|
|
except OSError as error:
|
|
print("droiddeck-game-env: install scripts not recorded (%s)" % error, file=sys.stderr)
|
|
|
|
|
|
def directaudio_settings(env):
|
|
if "directaudio" not in env.get("WINE_AUDIO_DRIVER", "").split(","):
|
|
return env
|
|
for name, value in list(env.items()):
|
|
if name.startswith("AUDIO_DIRECT_"):
|
|
env["BANNER_" + name] = value
|
|
return env
|
|
|
|
|
|
DIRT_GAMES = {"dirt3_game": "dirt3", "showdown": "dirtshowdown", "showdown_avx": "dirtshowdown"}
|
|
DIRT_WS2 = "/usr/local/lib/droiddeck-dirt/ws2_32.dll"
|
|
DIRT_MARKER = b"droiddeck-dirt-ws2_32"
|
|
DIRT_FIXED = "showdown_avx.exe".encode("utf-16-le")
|
|
DIRT_SAVED = ".droiddeck-original"
|
|
|
|
|
|
def dirt_telemetry_on(prefix, game):
|
|
try:
|
|
folders = [f for f in (Path(prefix) / "pfx/drive_c/users/steamuser/Documents/My Games").iterdir()
|
|
if f.name.lower().replace(" ", "") == game]
|
|
except OSError:
|
|
return False
|
|
for folder in folders:
|
|
try:
|
|
text = (folder / "hardwaresettings/hardware_settings_config.xml").read_text(encoding="latin-1")
|
|
except OSError:
|
|
continue
|
|
for tag in ("udp", "motion"):
|
|
element = re.search(r"<%s\s[^>]*>" % tag, text)
|
|
if element:
|
|
attrs = dict(re.findall(r'\s(\w+)="([^"]*)"', element.group(0)))
|
|
return attrs.get("enabled") == "true" and attrs.get("ip", "").lower() not in ("", "dbox")
|
|
return False
|
|
|
|
|
|
def proton_ws2(proton):
|
|
return Path(proton).parent / "files/lib/wine/i386-windows/ws2_32.dll"
|
|
|
|
|
|
def proton_has_dirt_fix(proton):
|
|
try:
|
|
return DIRT_FIXED in proton_ws2(proton).read_bytes()
|
|
except OSError:
|
|
return False
|
|
|
|
|
|
WINE_DLL_DIRS = ("/lib/wine/i386-windows", "/lib/wine/x86_64-windows", "/lib/wine/aarch64-windows", "/lib/wine",
|
|
"/lib/wine/fakedlls", "/lib64/wine", "/lib64/wine/fakedlls", "/lib64/wine/x86_64-windows")
|
|
|
|
|
|
def is_wine_dll_link(path):
|
|
try:
|
|
return os.path.islink(path) and os.path.dirname(os.readlink(path)).endswith(WINE_DLL_DIRS)
|
|
except OSError:
|
|
return False
|
|
|
|
|
|
def prefix_ws2(prefix):
|
|
return Path(prefix) / "pfx/drive_c/windows/syswow64/ws2_32.dll"
|
|
|
|
|
|
def is_dirt_stand_in(path):
|
|
try:
|
|
return not path.is_symlink() and DIRT_MARKER in path.read_bytes()
|
|
except OSError:
|
|
return False
|
|
|
|
|
|
def dirt_ws2_wanted(command, env):
|
|
prefix = env.get("STEAM_COMPAT_DATA_PATH", "").rstrip("/")
|
|
if len(command) < 3 or not prefix or not os.path.isfile(DIRT_WS2):
|
|
return None
|
|
game = DIRT_GAMES.get(os.path.splitext(os.path.basename(command[2]))[0].lower())
|
|
if not game or not dirt_telemetry_on(prefix, game) or proton_has_dirt_fix(command[0]):
|
|
return None
|
|
return prefix if os.path.lexists(prefix_ws2(prefix)) else None
|
|
|
|
|
|
def swap_dirt_ws2(prefix):
|
|
target = prefix_ws2(prefix)
|
|
saved = target.with_name(target.name + DIRT_SAVED)
|
|
data = Path(DIRT_WS2).read_bytes()
|
|
if not is_dirt_stand_in(target):
|
|
if os.path.lexists(saved):
|
|
os.unlink(saved)
|
|
os.replace(target, saved)
|
|
staged = target.with_name(target.name + ".droiddeck-tmp")
|
|
staged.write_bytes(data)
|
|
os.replace(staged, target)
|
|
|
|
|
|
def restore_dirt_ws2(prefix, proton):
|
|
target = prefix_ws2(prefix)
|
|
saved = target.with_name(target.name + DIRT_SAVED)
|
|
own = proton_ws2(proton)
|
|
had_saved = os.path.lexists(saved)
|
|
if had_saved:
|
|
if os.path.lexists(target) and not is_dirt_stand_in(target):
|
|
os.unlink(saved)
|
|
return False
|
|
if not own.is_file() or not is_wine_dll_link(saved) or os.path.realpath(saved) == os.path.realpath(own):
|
|
os.replace(saved, target)
|
|
return True
|
|
os.unlink(saved)
|
|
if own.is_file() and (is_dirt_stand_in(target) or (had_saved and not os.path.lexists(target))):
|
|
link = target.with_name(target.name + ".droiddeck-tmp")
|
|
if os.path.lexists(link):
|
|
os.unlink(link)
|
|
os.symlink(own, link)
|
|
os.replace(link, target)
|
|
return True
|
|
return False
|
|
|
|
|
|
EGO_RESTRICTIONS = "system/hardware_settings_restrictions.xml"
|
|
EGO_CORE_RULE = re.compile(r'[ \t]*<restrict_if name="cores" op="(int_[a-z]+)" value="(\d+)">.*?</restrict_if>[ \t]*\r?\n', re.S)
|
|
EGO_OPS = {"int_eq": int.__eq__, "int_ne": int.__ne__, "int_ge": int.__ge__, "int_gt": int.__gt__,
|
|
"int_le": int.__le__, "int_lt": int.__lt__}
|
|
|
|
|
|
def windows_core_count(env):
|
|
count = (env.get("WINE_CPU_TOPOLOGY") or "").split(":", 1)[0]
|
|
return int(count) if count.isascii() and count.isdigit() and int(count) > 0 else None
|
|
|
|
|
|
def ego_core_plan(command, env):
|
|
count = windows_core_count(env)
|
|
if not count or len(command) < 3:
|
|
return None
|
|
folder = Path(command[2]).parent
|
|
path = folder / EGO_RESTRICTIONS
|
|
try:
|
|
raw = path.read_bytes()
|
|
except OSError:
|
|
return None
|
|
text = raw.decode("latin-1")
|
|
start, end = text.find("<cpu>"), text.find("</cpu>")
|
|
if start < 0 or end < start:
|
|
return None
|
|
rules = list(EGO_CORE_RULE.finditer(text, start, end))
|
|
if not rules or any(EGO_OPS.get(rule.group(1), lambda a, b: True)(count, int(rule.group(2))) for rule in rules):
|
|
return None
|
|
smaller = [rule for rule in rules if rule.group(1) == "int_eq" and int(rule.group(2)) < count]
|
|
if not smaller:
|
|
return None
|
|
source = max(smaller, key=lambda rule: int(rule.group(2)))
|
|
worker_map = re.search(r'workerMapFile="([^"]+)"', source.group(0))
|
|
if worker_map and not (folder / worker_map.group(1)).is_file():
|
|
return None
|
|
plan = source.group(0).replace('value="%s"' % source.group(2), 'value="%d"' % count, 1)
|
|
saved = path.with_name(path.name + DIRT_SAVED)
|
|
if not os.path.lexists(saved):
|
|
saved.write_bytes(raw)
|
|
handle, staged = tempfile.mkstemp(prefix=path.name + ".", suffix=".droiddeck-tmp", dir=str(path.parent))
|
|
try:
|
|
with os.fdopen(handle, "wb") as out:
|
|
out.write((text[:source.end()] + plan + text[source.end():]).encode("latin-1"))
|
|
os.replace(staged, path)
|
|
except BaseException:
|
|
if os.path.lexists(staged):
|
|
os.unlink(staged)
|
|
raise
|
|
return "%s had no thread plan for %d cores; added a copy of its %s-core plan" % (EGO_RESTRICTIONS, count, source.group(2))
|
|
|
|
|
|
def wait_forwarding_signals_raw(process):
|
|
def forward(signum, frame):
|
|
try:
|
|
process.send_signal(signum)
|
|
except OSError:
|
|
pass
|
|
|
|
previous = {signum: signal.signal(signum, forward) for signum in (signal.SIGTERM, signal.SIGINT, signal.SIGHUP)}
|
|
try:
|
|
code = process.wait()
|
|
finally:
|
|
for signum, handler in previous.items():
|
|
signal.signal(signum, handler)
|
|
return code
|
|
|
|
|
|
def wait_forwarding_signals(process):
|
|
code = wait_forwarding_signals_raw(process)
|
|
return 128 - code if code < 0 else code
|
|
|
|
|
|
def diagnostic_game_event(event, app_id, values=None):
|
|
fields = ["event=" + event, "app_id=" + app_id]
|
|
fields.extend("%s=%s" % item for item in (values or {}).items())
|
|
print("DROIDDECK_DIAGNOSTICS " + " ".join(fields), file=sys.stderr, flush=True)
|
|
|
|
|
|
def diagnostic_game_exit(app_id, raw_code, source=None, wrapper_status=None):
|
|
normalized = 128 - raw_code if raw_code < 0 else raw_code
|
|
values = {
|
|
"raw_status": raw_code,
|
|
"normalized_status": normalized,
|
|
"wrapper_status": normalized if wrapper_status is None else wrapper_status,
|
|
"signal": -raw_code if raw_code < 0 else 0,
|
|
}
|
|
if source is not None:
|
|
values["source"] = source
|
|
diagnostic_game_event("game_exit", app_id, values)
|
|
|
|
|
|
def start(launch, launch_env, digest, after=None, diagnostic_app_id=None):
|
|
if len(launch) > 1 and launch[1] == "waitforexitandrun":
|
|
ubisoft_composition_off(launch[0], launch_env)
|
|
launch, launch_env = system_graphics_launch(launch, launch_env)
|
|
if after or diagnostic_app_id is not None:
|
|
process = subprocess.Popen(launch, env=launch_env)
|
|
if diagnostic_app_id is not None:
|
|
diagnostic_game_event("game_start", diagnostic_app_id)
|
|
try:
|
|
raw_code = wait_forwarding_signals_raw(process)
|
|
finally:
|
|
if after:
|
|
try:
|
|
after()
|
|
except OSError as error:
|
|
print("droiddeck-game-env: DiRT telemetry fix: prefix ws2_32 not put back (%s); the next launch does it" % error,
|
|
file=sys.stderr)
|
|
code = 128 - raw_code if raw_code < 0 else raw_code
|
|
if digest and after is None and code == 0:
|
|
record_install_scripts(digest, launch_env)
|
|
if diagnostic_app_id is not None:
|
|
diagnostic_game_exit(diagnostic_app_id, raw_code)
|
|
return code
|
|
if digest:
|
|
code = subprocess.run(launch, env=launch_env, check=False).returncode
|
|
if code == 0:
|
|
record_install_scripts(digest, launch_env)
|
|
return code
|
|
return os.execvpe(launch[0], launch, launch_env)
|
|
|
|
|
|
class SystemGraphicsError(ValueError):
|
|
pass
|
|
|
|
|
|
def system_graphics_launch(command, env):
|
|
"""Use the APK's PowerVR compatibility files only for actual Proton game launches."""
|
|
runtime = env.get("DROIDDECK_POWERVR_RUNTIME")
|
|
if not runtime or not game_id(env) or len(command) < 3 or command[1] != "waitforexitandrun":
|
|
return command, env
|
|
directory = Path(runtime)
|
|
if not directory.is_absolute():
|
|
raise SystemGraphicsError("system Vulkan runtime path is not absolute")
|
|
# run-proton.py picks the same payload by name; Xclipse needs a DXVK within 128 bytes of push data.
|
|
payload = env.get("DROIDDECK_HYBRIS_DXVK") or "dxvk"
|
|
if not payload.startswith("dxvk") or "/" in payload:
|
|
raise SystemGraphicsError("invalid DXVK payload name: %s" % payload)
|
|
required = (
|
|
"run-proton.py", "wsi/libVkLayer_window_system_integration.so",
|
|
"wsi/VkLayer_window_system_integration.json", "lib/libVkLayer_hybris_compat.so",
|
|
*("%s/%s/%s.dll" % (payload, arch, name) for arch in ("x32", "x64")
|
|
for name in ("d3d8", "d3d9", "d3d10core", "d3d11", "dxgi")),
|
|
)
|
|
try:
|
|
for name in required:
|
|
path = directory / name
|
|
if not path.is_file() or not path.stat().st_size:
|
|
raise SystemGraphicsError("missing system Vulkan component: %s" % name)
|
|
wrapper = directory / "run-proton.py"
|
|
if not os.access(wrapper, os.X_OK):
|
|
raise SystemGraphicsError("system Vulkan Proton wrapper is not executable")
|
|
except OSError as error:
|
|
raise SystemGraphicsError("system Vulkan component is unreadable: %s" % error) from error
|
|
result = dict(env)
|
|
layers = "VK_LAYER_window_system_integration:" + env.get("DROIDDECK_HYBRIS_LAYERS", "VK_LAYER_HYBRIS_compat")
|
|
result.update({
|
|
"HYBRIS_BC_TEXTURES": "dxvk",
|
|
"VK_LAYER_PATH": ":".join(filter(None, (str(directory / "wsi"), str(directory / "lib"),
|
|
env.get("DROIDDECK_HYBRIS_LAYER_PATH")))),
|
|
"VK_INSTANCE_LAYERS": layers,
|
|
"ENABLE_GAMESCOPE_WSI": "0",
|
|
"VK_LOADER_LAYERS_DISABLE": "*gamescope*",
|
|
"DISABLE_VK_LAYER_VALVE_steam_fossilize_1": "1",
|
|
})
|
|
for name in ("DISABLE_WSI_LAYER", "PROTON_USE_WINED3D", "ENABLE_VK_LAYER_VALVE_steam_fossilize_1"):
|
|
result.pop(name, None)
|
|
return [str(wrapper), *command], result
|
|
|
|
|
|
def game_logs(command, env, app_id, now=None):
|
|
"""Detailed graphics logs for one game launch, in the session's log folder: Proton's own log,
|
|
DXVK's and vkd3d-proton's, and the Vulkan driver's startup messages. The app turns this on
|
|
(BL_GAME_LOGS=1) on a GPU that is not an Adreno, or with Setup's "Detailed graphics logs"."""
|
|
if env.get("BL_GAME_LOGS") != "1" or not env.get("BL_DEBUG_DIR") or len(command) < 3 \
|
|
or command[1] != "waitforexitandrun":
|
|
return env
|
|
import time
|
|
stamp = time.strftime("%Y%m%d-%H%M%S", time.localtime(now))
|
|
name = app_id or re.sub(r"[^A-Za-z0-9._-]+", "_", Path(command[2]).stem)[:40] or "game"
|
|
parent = Path(env["BL_DEBUG_DIR"]) / "games"
|
|
try:
|
|
parent.mkdir(parents=True, exist_ok=True)
|
|
folder = Path(tempfile.mkdtemp(prefix=stamp + "-", suffix="-" + name, dir=parent))
|
|
except OSError as error:
|
|
print("droiddeck-game-env: no game log folder (%s)" % error, file=sys.stderr)
|
|
return env
|
|
result = dict(env)
|
|
result.update({
|
|
"PROTON_LOG": "1",
|
|
"PROTON_LOG_DIR": str(folder),
|
|
"DXVK_LOG_PATH": str(folder),
|
|
"DXVK_LOG_LEVEL": env.get("DXVK_LOG_LEVEL", "info"),
|
|
"VKD3D_LOG_FILE": str(folder / "vkd3d.log"),
|
|
"VKD3D_DEBUG": env.get("VKD3D_DEBUG", "warn"),
|
|
"VKD3D_SHADER_DEBUG": env.get("VKD3D_SHADER_DEBUG", "none"),
|
|
"MESA_LOG_FILE": str(folder / "mesa.log"),
|
|
"PANVK_DEBUG": env.get("PANVK_DEBUG", "startup"),
|
|
})
|
|
try:
|
|
(folder / "launch.txt").write_text("\n".join([
|
|
"app: %s" % (app_id or "-"),
|
|
"exe: %s" % command[2],
|
|
"proton: %s" % command[0],
|
|
"started: %s" % time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(now)),
|
|
] + ["%s=%s" % (key, env[key]) for key in sorted(env)
|
|
if key.startswith(("VK_", "BL_VK", "BL_DRM", "BL_OPEN", "MESA_", "PANVK", "DXVK_", "VKD3D", "ZINK", "TU_", "DROIDDECK_VKD3D"))]) + "\n")
|
|
except OSError:
|
|
pass
|
|
# Whether the game's sound reaches PulseAudio: the streams 20 s and 60 s in, without waiting.
|
|
try:
|
|
subprocess.Popen(["sh", "-c", 'for t in 20 40; do sleep $t; { echo "== $(date +%T)"; '
|
|
'pactl list sink-inputs 2>&1 | head -80; } >> "$1/audio-streams.txt"; done', "audio", str(folder)],
|
|
stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
|
|
start_new_session=True)
|
|
except OSError:
|
|
pass
|
|
return result
|
|
|
|
|
|
def exec_proton(command, env):
|
|
# Synchronization selection has already picked the actual Proton executable.
|
|
command, env = system_graphics_launch(command, env)
|
|
os.execvpe(command[0], command, env)
|
|
|
|
|
|
def main():
|
|
command = sys.argv[1:]
|
|
if not command:
|
|
return 2
|
|
env = game_gpu(os.environ.copy())
|
|
mic_enabled = env.get("BL_MIC_ENABLED")
|
|
debug_dir = env.get("BL_DEBUG_DIR", "")
|
|
scripts = mark_install_scripts(command, env)
|
|
if scripts and install_scripts_done(scripts, env):
|
|
print("droiddeck-game-env: install scripts already run in this prefix; evaluator skipped", file=sys.stderr)
|
|
return 0
|
|
try:
|
|
digest = scripts_digest(scripts) if scripts else None
|
|
except OSError:
|
|
digest = None
|
|
app_id = game_id(env)
|
|
waiting = bool(app_id and len(command) > 1 and command[1] == "waitforexitandrun")
|
|
diagnostic_app_id = app_id if waiting and os.environ.get("DROIDDECK_ENHANCED_DIAGNOSTICS") == "1" else None
|
|
dirt_prefix = None
|
|
if app_id:
|
|
gl_default = gl_vsync(env)
|
|
if waiting:
|
|
game_images(env)
|
|
fixes = {}
|
|
if waiting:
|
|
command = skip_red_launcher(command)
|
|
ubisoft_overlay_off(env)
|
|
project_zomboid_jvm(command)
|
|
fixes, extra, notes = engine_fixes(command[2], command[3:]) if len(command) > 2 else ({}, [], [])
|
|
if not gl_default:
|
|
fixes.pop("vblank_mode", None)
|
|
for note in notes:
|
|
print("droiddeck-game-env: " + note, file=sys.stderr)
|
|
command += extra
|
|
components = win_components(env.get("STEAM_COMPAT_DATA_PATH", ""), app_id)
|
|
if components:
|
|
own = fixes.get("WINEDLLOVERRIDES")
|
|
fixes["WINEDLLOVERRIDES"] = components + ";" + own if own else components
|
|
dirt_prefix = dirt_ws2_wanted(command, env)
|
|
if dirt_prefix:
|
|
own = fixes.get("WINEDLLOVERRIDES")
|
|
fixes["WINEDLLOVERRIDES"] = own + ";ws2_32=n,b" if own else "ws2_32=n,b"
|
|
path = Path.home() / ".config/droiddeck/game-environment.json"
|
|
config = {}
|
|
try:
|
|
with path.open(encoding="utf-8") as source:
|
|
config = json.load(source)
|
|
if waiting:
|
|
if "vblank_mode" in config.get("shared", {}):
|
|
fixes.pop("vblank_mode", None)
|
|
env = apply_config(env, config, app_id, fixes)
|
|
else:
|
|
env = apply_config(env, sync_config(config, app_id), app_id)
|
|
except FileNotFoundError:
|
|
if waiting:
|
|
env = apply_config(env, {"version": 1}, app_id, fixes)
|
|
except (OSError, ValueError, TypeError, AttributeError):
|
|
print("droiddeck-game-env: invalid configuration; using inherited environment", file=sys.stderr)
|
|
if waiting:
|
|
before_debug = env
|
|
env = apply_game_debug_logs(env, config, debug_dir)
|
|
if env is not before_debug:
|
|
print("droiddeck-game-env: game debug logs enabled for this launch", file=sys.stderr)
|
|
if gl_default and env.get("vblank_mode") == "0":
|
|
print("droiddeck-game-env: OpenGL does not wait for the screen refresh (vblank_mode=0)", file=sys.stderr)
|
|
if app_id and len(command) > 1 and command[1] == "waitforexitandrun":
|
|
command = offline_without_anticheat(command, env)
|
|
env = game_logs(command, env, app_id)
|
|
if mic_enabled == "0":
|
|
env["AUDIO_DIRECT_MIC"] = "0"
|
|
env = directaudio_settings(env)
|
|
env = vram_cap(env)
|
|
note = render_path_defaults(command, env) if app_id else None
|
|
if note:
|
|
print("droiddeck-game-env: " + note, file=sys.stderr)
|
|
note = bridge_feature_level(env)
|
|
if note:
|
|
print("droiddeck-game-env: " + note, file=sys.stderr)
|
|
env = force_ssbs(command, env)
|
|
game_cores(env)
|
|
cpu_topology(env, command)
|
|
if app_id and len(command) > 2 and command[1] == "waitforexitandrun":
|
|
try:
|
|
note = ego_core_plan(command, env)
|
|
except OSError as error:
|
|
note = "no thread plan added for this core count (%s)" % error
|
|
if note:
|
|
print("droiddeck-game-env: " + note, file=sys.stderr)
|
|
try:
|
|
xbox = runpy.run_path(str(Path(__file__).with_name("droiddeck-xbox")))
|
|
except Exception as error:
|
|
print("droiddeck-game-env: Xbox support unavailable (%s); stock launch" % error, file=sys.stderr)
|
|
xbox = {"launch": lambda command, env: None}
|
|
try:
|
|
xbox_result = xbox["launch"](command, env)
|
|
except (OSError, ValueError, KeyError, RuntimeError) as error:
|
|
print("droiddeck-game-env: Xbox launch could not start (%s)" % error, file=sys.stderr)
|
|
return 1
|
|
if xbox_result is not None:
|
|
if diagnostic_app_id is not None and isinstance(xbox_result, int):
|
|
diagnostic_game_exit(diagnostic_app_id, xbox_result, "xbox", xbox_result % 256)
|
|
return xbox_result
|
|
after = None
|
|
prefix = env.get("STEAM_COMPAT_DATA_PATH", "").rstrip("/")
|
|
if app_id and prefix and len(command) > 1 and command[1] == "waitforexitandrun":
|
|
try:
|
|
if dirt_prefix:
|
|
after = lambda: restore_dirt_ws2(dirt_prefix, command[0])
|
|
swap_dirt_ws2(dirt_prefix)
|
|
print("droiddeck-game-env: DiRT telemetry fix: ws2_32 stand-in in the prefix until the game exits",
|
|
file=sys.stderr)
|
|
elif restore_dirt_ws2(prefix, command[0]):
|
|
print("droiddeck-game-env: DiRT telemetry fix: put the prefix's own ws2_32 back", file=sys.stderr)
|
|
except OSError as error:
|
|
print("droiddeck-game-env: DiRT telemetry fix not applied (%s)" % error, file=sys.stderr)
|
|
if after:
|
|
after = None
|
|
try:
|
|
restore_dirt_ws2(dirt_prefix, command[0])
|
|
except OSError as undo:
|
|
print("droiddeck-game-env: DiRT telemetry fix: prefix ws2_32 not put back (%s); Wine uses its own copy "
|
|
"and the next launch puts the file back" % undo, file=sys.stderr)
|
|
sync = load_sync()
|
|
launch, launch_env = select_sync(command, env, sync)
|
|
if launch[0] != command[0]:
|
|
try:
|
|
return start(launch, launch_env, digest, after, diagnostic_app_id)
|
|
except OSError as error:
|
|
print("droiddeck-game-env: %s could not start (%s); stock launch" % (launch[0], error), file=sys.stderr)
|
|
launch, launch_env = command, without_pack(launch_env, env)
|
|
record_stock(sync, launch, launch_env)
|
|
try:
|
|
return start(launch, launch_env, digest, after, diagnostic_app_id)
|
|
except OSError:
|
|
if after:
|
|
try:
|
|
after()
|
|
except OSError as error:
|
|
print("droiddeck-game-env: DiRT telemetry fix: prefix ws2_32 not put back (%s); the next launch does it" % error,
|
|
file=sys.stderr)
|
|
raise
|
|
|
|
|
|
if __name__ == "__main__":
|
|
try:
|
|
sys.exit(main())
|
|
except SystemGraphicsError as error:
|
|
print("droiddeck-game-env: PowerVR graphics runtime unavailable (%s)" % error, file=sys.stderr)
|
|
sys.exit(1)
|