mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-21 05:46:03 +00:00
DOOM (2016) asks for exactly two swapchain images and stops with "FATAL ERROR: getSwapchainImagesKHR failed with error (VK_SUCCESS)" when it gets more. Every game launch gets GAMESCOPE_WSI_MIN_IMAGE_COUNT=8 and GAMESCOPE_WSI_ENSURE_MIN_IMAGE_COUNT=1, so gamescope's WSI layer gave it 8 images (3 with only the count removed) and the game crashed on start. When DOOMx64vk.exe sits beside the launched program (DOOMx64.exe for a GOG install, or DOOMx64vk.exe), both variables are removed and vk_x11_strict_image_count=true is set, the option Mesa's driconf gives the game. Other games keep the defaults. A per-game value in the environment editor still wins. Tested on an AYANEO Pocket FIT with DroidDeck 0.6.9 and the same values set per game: the swapchain gets 2 images and the game reaches its main menu at 60 fps; before, it crashed on every launch.
1042 lines
38 KiB
Python
Executable File
1042 lines
38 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"
|
|
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 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)"
|
|
|
|
|
|
@fix
|
|
def caravan_sandwitch_feature_level(game):
|
|
if "caravansandwitch.exe" in game.files or game.stem == "caravansandwitch-win64-shipping":
|
|
return {"VKD3D_FEATURE_LEVEL": "12_1"}, [], "Caravan SandWitch: D3D12 feature level 12_1 (12_2 hands it mesh shader pipelines vkd3d-proton cannot build)"
|
|
|
|
|
|
@fix
|
|
def robocop_rogue_city_feature_level(game):
|
|
if "robocop.exe" in game.files or game.stem == "robocop-win64-shipping":
|
|
return {"VKD3D_FEATURE_LEVEL": "12_1"}, [], "RoboCop: Rogue City: D3D12 feature level 12_1"
|
|
|
|
|
|
@fix
|
|
def reskate_feature_level(game):
|
|
if "skate.exe" in game.files and "reskate.dll" in game.files:
|
|
return {"VKD3D_FEATURE_LEVEL": "12_1"}, [], "ReSkate (skate.): D3D12 feature level 12_1"
|
|
|
|
|
|
@fix
|
|
def cyberpunk_feature_level(game):
|
|
if game.stem == "cyberpunk2077" or (
|
|
game.stem == "redprelauncher"
|
|
and os.path.isfile(os.path.join(os.path.dirname(game.exe), "bin", "x64", "Cyberpunk2077.exe"))
|
|
):
|
|
return {"VKD3D_FEATURE_LEVEL": "12_1"}, [], "Cyberpunk 2077: D3D12 feature level 12_1"
|
|
|
|
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 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 game_gpu(env):
|
|
if GAME_TU_DEBUG not in env:
|
|
return env
|
|
result = env.copy()
|
|
value = result.pop(GAME_TU_DEBUG)
|
|
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
|
|
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
|
|
return result
|
|
|
|
|
|
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(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 128 - code if code < 0 else code
|
|
|
|
|
|
def start(launch, launch_env, digest, after=None):
|
|
if after:
|
|
process = subprocess.Popen(launch, env=launch_env)
|
|
try:
|
|
return wait_forwarding_signals(process)
|
|
finally:
|
|
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)
|
|
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)
|
|
|
|
|
|
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)
|
|
dirt_prefix = None
|
|
if app_id:
|
|
gl_default = gl_vsync(env)
|
|
waiting = len(command) > 1 and command[1] == "waitforexitandrun"
|
|
if waiting:
|
|
game_images(env)
|
|
fixes = {}
|
|
if waiting:
|
|
command = skip_red_launcher(command)
|
|
ubisoft_overlay_off(env)
|
|
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)
|
|
if mic_enabled == "0":
|
|
env["AUDIO_DIRECT_MIC"] = "0"
|
|
env = directaudio_settings(env)
|
|
env = vram_cap(env)
|
|
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:
|
|
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)
|
|
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)
|
|
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__":
|
|
sys.exit(main())
|