diff --git a/tools/airdef.py b/tools/airdef.py index 42a12fd..0864dc9 100644 --- a/tools/airdef.py +++ b/tools/airdef.py @@ -2,7 +2,7 @@ """AirDef: сборка, установка и запуск на Windows, macOS и Linux. Только стандартная библиотека Python. python3 tools/airdef.py fork # инициализировать закреплённый сабмодуль Horizon (horizon/) - python3 tools/airdef.py game # собрать игру (форк) — нужен Rust; на Windows + NVIDIA RTX с DLSS SDK добавляет feature dlss + python3 tools/airdef.py game # собрать игру (форк) — нужен Rust; на Windows + NVIDIA RTX сам скачивает DLSS SDK python3 tools/airdef.py mod # собрать мод airdef.hmod — нужен Rust с wasm32 python3 tools/airdef.py install # положить мод в папку игры и включить python3 tools/airdef.py play [аргументы игры] # запустить форк на папке игры @@ -12,8 +12,10 @@ python3 tools/airdef.py test-budgets # тяжёлый WASM budget сценарий + JSON provenance Переменные окружения: HORIZON_HOME (папка игры), HORIZON_RESOURCES (подготовленные ресурсы -Minecraft 26.3), AIRDEF_GAME (готовый horizon-client вместо собранного), DLSS_SDK и VULKAN_SDK -(сборка game с feature dlss на Windows + NVIDIA RTX). +Minecraft 26.3), AIRDEF_GAME (готовый horizon-client вместо собранного). +На Windows + NVIDIA RTX сборка с DLSS (feature dlss) сама скачивает DLSS SDK и заголовки Vulkan +в .horizon-cache/ и кладёт nvngx_dlss.dll рядом с horizon-client.exe. Явные DLSS_SDK и VULKAN_SDK +по-прежнему имеют приоритет над автоскачиванием; при сбое сети собирается обычный mods/TAAU. """ import glob import hashlib @@ -25,6 +27,7 @@ import shutil import subprocess import sys import tempfile +import urllib.request import zipfile from pathlib import Path @@ -102,8 +105,231 @@ def fork(): sys.exit(f"horizon/: ожидался {expected}, получен {current}") -DLSS_SDK_URL = "https://github.com/NVIDIA/DLSS/tree/v310.9.1" +DLSS_SDK_URL = "https://github.com/NVIDIA/DLSS" +DLSS_TAGS_API = "https://api.github.com/repos/NVIDIA/DLSS/tags?per_page=30" +DLSS_RAW = "https://raw.githubusercontent.com/NVIDIA/DLSS/{tag}/{path}" +DLSS_TAG_PINNED = "v310.9.1" +# Автоскачивание берёт только стабильные v310.9.x; закреплённая версия — резерв при сбое API. +DLSS_TAG = re.compile(r"^v310\.9\.(\d+)$") +DLSS_INCLUDE_FALLBACK = ( + "nvsdk_ngx.h", "nvsdk_ngx_defs.h", "nvsdk_ngx_defs_dlssd.h", "nvsdk_ngx_defs_dlssg.h", + "nvsdk_ngx_defs_vk.h", "nvsdk_ngx_helpers.h", "nvsdk_ngx_helpers_cuda.h", + "nvsdk_ngx_helpers_d3d.h", "nvsdk_ngx_helpers_dlssd.h", "nvsdk_ngx_helpers_dlssd_cuda.h", + "nvsdk_ngx_helpers_dlssd_d3d.h", "nvsdk_ngx_helpers_dlssd_vk.h", "nvsdk_ngx_helpers_dlssg.h", + "nvsdk_ngx_helpers_dlssg_d3d.h", "nvsdk_ngx_helpers_dlssg_vk.h", "nvsdk_ngx_helpers_vk.h", + "nvsdk_ngx_loader.h", "nvsdk_ngx_params.h", "nvsdk_ngx_params_dlssd.h", + "nvsdk_ngx_params_dlssg.h", "nvsdk_ngx_standalone_common.h", "nvsdk_ngx_standalone_cuda.h", + "nvsdk_ngx_vk.h", +) +# dlss_wgpu линкует static-библиотеку (nvsdk_ngx_d, либо nvsdk_ngx_s при crt-static). +DLSS_LIBS = ("lib/Windows_x86_64/x64/nvsdk_ngx_d.lib", "lib/Windows_x86_64/x64/nvsdk_ngx_s.lib") +DLSS_RUNTIME = "lib/Windows_x86_64/rel/nvngx_dlss.dll" + VULKAN_SDK_URL = "https://vulkan.lunarg.com/sdk/home" +VULKAN_TAG_PINNED = "vulkan-sdk-1.4.363.0" +VULKAN_RAW = "https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/{tag}/include/{path}" +# build.rs использует только заголовки ({VULKAN_SDK}/Include), полный LunarG SDK не нужен. +VULKAN_HEADERS = ( + "vulkan/vulkan.h", "vulkan/vulkan_core.h", "vulkan/vk_platform.h", + "vk_video/vulkan_video_codec_av1std.h", "vk_video/vulkan_video_codec_av1std_decode.h", + "vk_video/vulkan_video_codec_av1std_encode.h", "vk_video/vulkan_video_codec_h264std.h", + "vk_video/vulkan_video_codec_h264std_decode.h", "vk_video/vulkan_video_codec_h264std_encode.h", + "vk_video/vulkan_video_codec_h265std.h", "vk_video/vulkan_video_codec_h265std_decode.h", + "vk_video/vulkan_video_codec_h265std_encode.h", "vk_video/vulkan_video_codec_vp9std.h", + "vk_video/vulkan_video_codec_vp9std_decode.h", "vk_video/vulkan_video_codecs_common.h", +) + +CACHE = ROOT / ".horizon-cache" +DLSS_CACHE = CACHE / "dlss-sdk" +VULKAN_CACHE = CACHE / "vulkan-headers" +INSTALL_MARKER = "airdef-install.json" + + +class DownloadError(RuntimeError): + """Сеть или неполный файл при автоскачивании; вызывающий код откатывается на mods.""" + + +def open_url(url): + request = urllib.request.Request(url, headers={"User-Agent": "airdef-dlss-autoinstall"}) + return urllib.request.urlopen(request, timeout=120) + + +def github_json(url): + with open_url(url) as response: + return json.load(response) + + +def download(url, dest): + """Один файл потоком во временный .part и атомарная замена; прогресс для больших файлов.""" + dest = Path(dest) + dest.parent.mkdir(parents=True, exist_ok=True) + part = dest.with_name(dest.name + ".part") + try: + try: + response = open_url(url) + except Exception as exc: + raise DownloadError(f"{url}: {exc}") from exc + with response, open(part, "wb") as out: + total = int(response.headers.get("Content-Length") or 0) + big = total >= 8_000_000 + if big: + print(f" {dest.name}: {total / 1e6:.1f} МБ", flush=True) + done, step = 0, 0 + while True: + chunk = response.read(1 << 20) + if not chunk: + break + out.write(chunk) + done += len(chunk) + if big and done * 10 // total > step: + step = done * 10 // total + print(f" {dest.name}: {min(step * 10, 100)}%", flush=True) + if total and done < total: + raise DownloadError(f"{url}: получено {done} из {total} байт") + os.replace(part, dest) + finally: + if part.exists(): + part.unlink() + + +def dlss_latest_tag(): + """Новейший стабильный тег v310.9.x с GitHub; при сбое API — закреплённый v310.9.1.""" + try: + tags = github_json(DLSS_TAGS_API) + except Exception as exc: + print(f"Внимание: не удалось получить теги DLSS ({exc}); беру {DLSS_TAG_PINNED}.", flush=True) + return DLSS_TAG_PINNED + versions = [] + for entry in tags if isinstance(tags, list) else []: + name = entry.get("name", "") if isinstance(entry, dict) else "" + match = DLSS_TAG.match(name) + if match: + versions.append((int(match.group(1)), name)) + if not versions: + print(f"Внимание: среди тегов DLSS нет v310.9.x; беру {DLSS_TAG_PINNED}.", flush=True) + return DLSS_TAG_PINNED + return max(versions)[1] + + +def dlss_include_files(tag): + """Список include/*.h тега из API; при сбое — закреплённый набор v310.9.x.""" + try: + entries = github_json(f"https://api.github.com/repos/NVIDIA/DLSS/contents/include?ref={tag}") + names = [entry["name"] for entry in entries if isinstance(entry, dict) + and str(entry.get("name", "")).endswith(".h")] + if names: + return names + except Exception: + pass + return list(DLSS_INCLUDE_FALLBACK) + + +def read_marker(path): + """Манифест установки в кэше (версия, размер DLL); None, если его нет или он битый.""" + try: + return json.loads((Path(path) / INSTALL_MARKER).read_text(encoding="utf-8")) + except (OSError, ValueError): + return None + + +def dlss_sdk_complete(path) -> bool: + """Полный набор для сборки: include, обе static .lib и runtime DLL.""" + path = Path(path) + return valid_dlss_sdk(path) and all((path / rel).is_file() for rel in DLSS_LIBS + (DLSS_RUNTIME,)) + + +def dlss_tag_key(name): + match = DLSS_TAG.match(name) + return int(match.group(1)) if match else -1 + + +def cached_dlss_sdk(): + """Самый новый полностью скачанный SDK в кэше или None.""" + if not DLSS_CACHE.is_dir(): + return None + for path in sorted(DLSS_CACHE.iterdir(), key=lambda p: dlss_tag_key(p.name), reverse=True): + state = read_marker(path) + if state and state.get("tag") == path.name and dlss_sdk_complete(path): + return path + return None + + +def install_dlss_sdk(tag=None): + """Скачивает только нужные файлы NVIDIA/DLSS в .horizon-cache/dlss-sdk/. + + Раскладка ровно та, которую ожидает dlss_wgpu: include/nvsdk_ngx*.h и lib/Windows_x86_64/{x64,rel}. + """ + tag = tag or dlss_latest_tag() + dest = DLSS_CACHE / tag + state = read_marker(dest) + if state and state.get("tag") == tag and dlss_sdk_complete(dest): + print(f"DLSS SDK {tag}: уже в кэше {dest}", flush=True) + return dest + print(f"DLSS SDK {tag}: скачиваю заголовки, .lib и nvngx_dlss.dll (~67 МБ) с {DLSS_SDK_URL}", flush=True) + staging = DLSS_CACHE / f".{tag}.part" + shutil.rmtree(staging, ignore_errors=True) + try: + for name in dlss_include_files(tag): + download(DLSS_RAW.format(tag=tag, path=f"include/{name}"), staging / "include" / name) + for rel in DLSS_LIBS + (DLSS_RUNTIME,): + download(DLSS_RAW.format(tag=tag, path=rel), staging / rel) + if not dlss_sdk_complete(staging): + raise DownloadError(f"DLSS SDK {tag}: после скачивания нет полного набора include/ и lib/Windows_x86_64") + (staging / INSTALL_MARKER).write_text(json.dumps({ + "tag": tag, "source": DLSS_SDK_URL, + "dll_bytes": (staging / DLSS_RUNTIME).stat().st_size}, indent=2) + "\n", encoding="utf-8") + shutil.rmtree(dest, ignore_errors=True) + staging.rename(dest) + except Exception: + shutil.rmtree(staging, ignore_errors=True) + raise + print(f"DLSS SDK {tag}: готов, {dest}", flush=True) + return dest + + +def vulkan_headers_ok(path) -> bool: + """dlss_wgpu ищет Include/vulkan/vulkan.h (Windows) или include/vulkan/vulkan.h.""" + if not path: + return False + path = Path(path) + return any((path / part).is_file() for part in + ("Include/vulkan/vulkan.h", "include/vulkan/vulkan.h")) + + +def vulkan_cache_ok(path, tag) -> bool: + state = read_marker(path) + return bool(state) and state.get("tag") == tag and vulkan_headers_ok(path) \ + and (Path(path) / "Include" / "vk_video" / "vulkan_video_codecs_common.h").is_file() + + +def cached_vulkan_headers(): + path = VULKAN_CACHE / VULKAN_TAG_PINNED + return path if vulkan_cache_ok(path, VULKAN_TAG_PINNED) else None + + +def install_vulkan_headers(tag=VULKAN_TAG_PINNED): + """Только заголовки Khronos в /Include: build.rs линкует Vulkan-библиотеку сам.""" + dest = VULKAN_CACHE / tag + if vulkan_cache_ok(dest, tag): + print(f"Vulkan-заголовки {tag}: уже в кэше {dest}", flush=True) + return dest + print(f"Vulkan-заголовки {tag}: скачиваю include/ (полный LunarG SDK не нужен)", flush=True) + staging = VULKAN_CACHE / f".{tag}.part" + shutil.rmtree(staging, ignore_errors=True) + try: + for rel in VULKAN_HEADERS: + download(VULKAN_RAW.format(tag=tag, path=rel), staging / "Include" / rel) + if not vulkan_headers_ok(staging): + raise DownloadError(f"Vulkan-заголовки {tag}: после скачивания нет Include/vulkan/vulkan.h") + (staging / INSTALL_MARKER).write_text(json.dumps({"tag": tag, "source": VULKAN_SDK_URL}, + indent=2) + "\n", encoding="utf-8") + shutil.rmtree(dest, ignore_errors=True) + staging.rename(dest) + except Exception: + shutil.rmtree(staging, ignore_errors=True) + raise + print(f"Vulkan-заголовки {tag}: готовы, {dest}", flush=True) + return dest def gpu_names(): @@ -134,13 +360,13 @@ def rtx_gpu(names) -> bool: def valid_dlss_sdk(path) -> bool: - """Каталоги, без которых dlss_wgpu не соберётся: include/nvngx*.h и lib/Windows_x86_64/x64.""" - return bool(path) and (path / "include").is_dir() and list((path / "include").glob("nvngx*.h")) \ + """Каталоги, без которых dlss_wgpu не соберётся: include/nvsdk_ngx*.h и lib/Windows_x86_64/x64.""" + return bool(path) and (path / "include").is_dir() and list((path / "include").glob("nvsdk_ngx*.h")) \ and (path / "lib" / "Windows_x86_64" / "x64").is_dir() def dlss_sdk_path(): - """Корень NVIDIA DLSS SDK v310.9.1 или None.""" + """Корень уже установленного NVIDIA DLSS SDK (DLSS_SDK, ROOT/DLSS, Program Files) или None.""" candidates = [] if os.environ.get("DLSS_SDK"): candidates.append(Path(os.environ["DLSS_SDK"])) @@ -154,47 +380,122 @@ def dlss_sdk_path(): return None -def dlss_build_features(system=None, gpus=None, sdk=None) -> str: - """Features сборки клиента: 'mods,dlss' только на Windows + RTX при готовом SDK, иначе 'mods'. +def _auto_install(install, label): + """Автоскачивание не должно ломать сборку: любая ошибка — предупреждение и mods/TAAU.""" + try: + return install() + except Exception as exc: + print(f"Внимание: {label} не скачался: {exc}", flush=True) + return None - Нет SDK на Windows + RTX — предупреждение с инструкцией и обычная сборка без DLSS. + +def dlss_build_plan(system=None, gpus=None, sdk=None) -> dict: + """Features сборки и окружение DLSS_SDK/VULKAN_SDK для Windows + NVIDIA RTX. + + Возвращает {"features", "env", "sdk", "dll"}. Без явного SDK на Windows + RTX сам скачивает + DLSS SDK и заголовки Vulkan в .horizon-cache. Явные DLSS_SDK/VULKAN_SDK (или аргумент sdk) + имеют приоритет и отключают автоскачивание; неполный явный путь — предупреждение и mods. """ + plan = {"features": "mods", "env": {}, "sdk": None, "dll": None} system = platform.system() if system is None else system if system != "Windows": - return "mods" + return plan names = gpu_names() if gpus is None else gpus if not rtx_gpu(names): - return "mods" - if sdk is None: - sdk_root = dlss_sdk_path() - else: + return plan + + env_sdk = os.environ.get("DLSS_SDK") + explicit_sdk = sdk is not None or bool(env_sdk) + if sdk is not None: candidate = Path(sdk) sdk_root = candidate if valid_dlss_sdk(candidate) else None - vulkan = os.environ.get("VULKAN_SDK") - # dlss_wgpu ищет заголовки Vulkan в Include (Windows) или include. - vulkan_ok = bool(vulkan) and any((Path(vulkan) / part).is_file() for part in - ("Include/vulkan/vulkan.h", "include/vulkan/vulkan.h")) + elif env_sdk: + candidate = Path(env_sdk) + sdk_root = candidate if valid_dlss_sdk(candidate) else None + else: + sdk_root = dlss_sdk_path() or cached_dlss_sdk() + if sdk_root is None: + sdk_root = _auto_install(install_dlss_sdk, "NVIDIA DLSS SDK") + + env_vulkan = os.environ.get("VULKAN_SDK") + explicit_vulkan = bool(env_vulkan) + if env_vulkan: + vulkan_root = Path(env_vulkan) if vulkan_headers_ok(env_vulkan) else None + else: + vulkan_root = cached_vulkan_headers() + if vulkan_root is None: + vulkan_root = _auto_install(install_vulkan_headers, "Vulkan-заголовки") + missing = [] if sdk_root is None: - missing.append(f"NVIDIA DLSS SDK v310.9.1 (переменная DLSS_SDK, {DLSS_SDK_URL})") - if not vulkan_ok: - missing.append(f"Vulkan SDK (переменная VULKAN_SDK, {VULKAN_SDK_URL})") + missing.append("NVIDIA DLSS SDK") + if vulkan_root is None: + missing.append("заголовки Vulkan") if missing: print("Внимание: NVIDIA RTX найден, но DLSS-сборка пропущена — нет " + " и ".join(missing) + ".", flush=True) - print(" DLSS SDK: скачай v310.9.1 и задай DLSS_SDK на корень SDK (include/ и lib/).", flush=True) - print(" Vulkan SDK: установи и задай VULKAN_SDK на корень SDK.", flush=True) + if explicit_sdk or explicit_vulkan: + print(" DLSS_SDK/VULKAN_SDK заданы, но путь неполный. Убери их, и airdef.py скачает SDK сам.", + flush=True) + else: + print(" Автоскачивание не удалось: проверь сеть/прокси и повтори сборку.", flush=True) + print(f" Вручную: DLSS SDK {DLSS_SDK_URL} (переменная DLSS_SDK), Vulkan SDK или только " + f"заголовки (VULKAN_SDK, {VULKAN_SDK_URL}).", flush=True) print(" Собираю --features mods: DLSS выключен, native TAAU остаётся.", flush=True) - return "mods" + return plan + + plan.update(features="mods,dlss", sdk=sdk_root, dll=Path(sdk_root) / DLSS_RUNTIME, + env={"DLSS_SDK": str(sdk_root), "VULKAN_SDK": str(vulkan_root)}) print(f"DLSS: NVIDIA RTX, SDK {sdk_root}; собираю --features mods,dlss", flush=True) - print(" nvngx_dlss.dll положи рядом с horizon-client.exe; DLSS включён по умолчанию — переключатель в настройках мода (N → DLSS), HORIZON_DLSS=1|0 переопределяет.", flush=True) - return "mods,dlss" + print(" nvngx_dlss.dll из SDK кладу рядом с horizon-client.exe после сборки; DLSS включён по умолчанию — переключатель в настройках мода (N → DLSS), HORIZON_DLSS=1|0 переопределяет.", flush=True) + return plan + + +def dlss_build_features(system=None, gpus=None, sdk=None) -> str: + """Строка features для cargo build: 'mods,dlss' только на Windows + RTX с полным SDK.""" + return dlss_build_plan(system=system, gpus=gpus, sdk=sdk)["features"] + + +def built_client_candidates(): + paths = [] + if os.environ.get("AIRDEF_GAME"): + paths.append(Path(os.environ["AIRDEF_GAME"])) + paths += [FORK / "target" / "fast" / ("horizon-client" + EXE), ROOT / ("horizon-client" + EXE)] + return paths + + +def place_dlss_runtime(sdk_root): + """Копирует свежий nvngx_dlss.dll из SDK рядом с собранным horizon-client.exe.""" + dll = Path(sdk_root) / DLSS_RUNTIME + if not dll.is_file(): + print(f"Внимание: в SDK {sdk_root} нет {DLSS_RUNTIME}; положи nvngx_dlss.dll рядом с клиентом вручную.", + flush=True) + return None + for exe in built_client_candidates(): + if not exe.is_file(): + continue + target = exe.with_name(dll.name) + try: + # Всегда свежая DLL: старый nvngx_dlss.dll рядом с клиентом не должен пережить пересборку. + shutil.copy2(dll, target) + print(f" nvngx_dlss.dll ({dll.stat().st_size / 1e6:.1f} МБ) рядом с {exe}", flush=True) + return target + except OSError as exc: + print(f"Внимание: не удалось положить {dll.name} рядом с {exe}: {exc}", flush=True) + print("Внимание: собранный horizon-client.exe не найден; nvngx_dlss.dll нужно положить рядом с ним вручную.", + flush=True) + return None def game(): fork() - run([cargo(), "build", "--profile", "fast", "-p", "horizon-client", "--features", dlss_build_features()], - cwd=FORK) + plan = dlss_build_plan() + env = dict(os.environ) + env.update(plan["env"]) + run([cargo(), "build", "--profile", "fast", "-p", "horizon-client", "--features", plan["features"]], + cwd=FORK, env=env) + if plan["sdk"] is not None: + place_dlss_runtime(plan["sdk"]) def built_game() -> Path: diff --git a/tools/test_airdef_build.py b/tools/test_airdef_build.py index d3d36f7..fb91430 100644 --- a/tools/test_airdef_build.py +++ b/tools/test_airdef_build.py @@ -2,6 +2,7 @@ import contextlib import importlib.util import io +import json import os from pathlib import Path import subprocess @@ -69,7 +70,7 @@ class DlssBuildFeatureTests(unittest.TestCase): self.root = Path(self.tmp.name) self.sdk = self.root / "DLSS" (self.sdk / "include").mkdir(parents=True) - (self.sdk / "include" / "nvngx_dlss.h").write_text("") + (self.sdk / "include" / "nvsdk_ngx.h").write_text("") (self.sdk / "lib" / "Windows_x86_64" / "x64").mkdir(parents=True) self.vulkan = self.root / "VulkanSDK" (self.vulkan / "Include" / "vulkan").mkdir(parents=True) @@ -80,7 +81,9 @@ class DlssBuildFeatureTests(unittest.TestCase): def features(self, **kwargs): out = io.StringIO() - with patch.dict(os.environ, {"VULKAN_SDK": str(self.vulkan)}), contextlib.redirect_stdout(out): + # Пустые DLSS_SDK/VULKAN_SDK — «не заданы»: автоскачивание в этих тестах не нужно. + with patch.dict(os.environ, {"VULKAN_SDK": str(self.vulkan), "DLSS_SDK": ""}), \ + contextlib.redirect_stdout(out): return airdef.dlss_build_features(**kwargs), out.getvalue() def test_non_windows_is_mods_even_with_rtx_and_sdk(self): @@ -125,12 +128,344 @@ class DlssBuildFeatureTests(unittest.TestCase): def test_game_builds_with_the_detected_feature_string(self): commands = [] + plan = {"features": "mods,dlss", "env": {}, "sdk": self.sdk, "dll": None} with patch.object(airdef, "fork"), patch.object(airdef, "cargo", return_value="cargo"), \ patch.object(airdef, "run", side_effect=lambda cmd, cwd=None, env=None: commands.append(cmd)), \ - patch.object(airdef, "dlss_build_features", return_value="mods,dlss"): + patch.object(airdef, "dlss_build_plan", return_value=plan), \ + patch.object(airdef, "place_dlss_runtime"): airdef.game() self.assertEqual(commands[-1][-1], "mods,dlss") +class FakeResponse: + """Мини-ответ urlopen: поток чтения и Content-Length, как у настоящего HTTP-ответа.""" + + def __init__(self, payload, total=None): + self.payload = payload + self.pos = 0 + self.headers = {"Content-Length": str(len(payload) if total is None else total)} + + def read(self, size=-1): + chunk = self.payload[self.pos:self.pos + size] + self.pos += len(chunk) + return chunk + + def __enter__(self): + return self + + def __exit__(self, *exc): + return False + + +class DownloadTests(unittest.TestCase): + """download(): поток, атомарная замена и явная ошибка на неполном файле.""" + + def setUp(self): + self.tmp = tempfile.TemporaryDirectory(prefix="airdef-download-test-") + self.addCleanup(self.tmp.cleanup) + self.root = Path(self.tmp.name) + + def test_download_writes_file_and_leaves_no_part(self): + with patch.object(airdef, "open_url", return_value=FakeResponse(b"payload")): + airdef.download("https://example.invalid/a.bin", self.root / "sub" / "a.bin") + self.assertEqual((self.root / "sub" / "a.bin").read_bytes(), b"payload") + self.assertFalse((self.root / "sub" / "a.bin.part").exists()) + + def test_truncated_download_fails_without_placing_the_file(self): + with patch.object(airdef, "open_url", return_value=FakeResponse(b"short", total=100)): + with self.assertRaises(airdef.DownloadError): + airdef.download("https://example.invalid/a.bin", self.root / "a.bin") + self.assertFalse((self.root / "a.bin").exists()) + self.assertFalse((self.root / "a.bin.part").exists()) + + def test_network_error_is_wrapped_as_download_error(self): + with patch.object(airdef, "open_url", side_effect=OSError("no route")): + with self.assertRaises(airdef.DownloadError): + airdef.download("https://example.invalid/a.bin", self.root / "a.bin") + + +class DlssVersionTests(unittest.TestCase): + """Выбор тега: самый новый v310.9.x, при сбое API — закреплённый v310.9.1.""" + + def test_picks_newest_v310_9_x(self): + tags = [{"name": "v310.9.9"}, {"name": "v310.9.16"}, {"name": "v310.7.0"}, {"name": "docs"}] + with patch.object(airdef, "github_json", return_value=tags), contextlib.redirect_stdout(io.StringIO()): + self.assertEqual(airdef.dlss_latest_tag(), "v310.9.16") + + def test_api_failure_falls_back_to_pinned_tag(self): + out = io.StringIO() + with patch.object(airdef, "github_json", side_effect=OSError("rate limited")), \ + contextlib.redirect_stdout(out): + self.assertEqual(airdef.dlss_latest_tag(), airdef.DLSS_TAG_PINNED) + self.assertIn("v310.9.1", out.getvalue()) + + def test_include_list_comes_from_api(self): + entries = [{"name": "nvsdk_ngx.h"}, {"name": "README.md"}] + with patch.object(airdef, "github_json", return_value=entries): + self.assertEqual(airdef.dlss_include_files("v310.9.16"), ["nvsdk_ngx.h"]) + + def test_include_list_falls_back_to_pinned_names(self): + with patch.object(airdef, "github_json", side_effect=OSError("offline")): + names = airdef.dlss_include_files("v310.9.16") + self.assertIn("nvsdk_ngx.h", names) + self.assertIn("nvsdk_ngx_helpers_vk.h", names) + self.assertIn("nvsdk_ngx_helpers_dlssd_vk.h", names) + + +class DlssAutoInstallTests(unittest.TestCase): + """install_dlss_sdk/install_vulkan_headers: раскладка кэша, маркер и повторное использование.""" + + def setUp(self): + self.tmp = tempfile.TemporaryDirectory(prefix="airdef-dlss-install-") + self.addCleanup(self.tmp.cleanup) + self.cache = Path(self.tmp.name) + self.dlss_cache = self.cache / "dlss-sdk" + self.vulkan_cache = self.cache / "vulkan-headers" + self.downloads = [] + self.offline = set() + patches = [ + patch.object(airdef, "DLSS_CACHE", self.dlss_cache), + patch.object(airdef, "VULKAN_CACHE", self.vulkan_cache), + patch.object(airdef, "dlss_latest_tag", return_value="v310.9.16"), + patch.object(airdef, "dlss_include_files", + return_value=["nvsdk_ngx.h", "nvsdk_ngx_helpers_vk.h"]), + patch.object(airdef, "download", side_effect=self.fake_download), + ] + for item in patches: + item.start() + self.addCleanup(item.stop) + + def fake_download(self, url, dest): + if url in self.offline: + raise airdef.DownloadError(f"{url}: simulated offline") + self.downloads.append((url, Path(dest))) + Path(dest).parent.mkdir(parents=True, exist_ok=True) + Path(dest).write_bytes(b"binary" * 4) + + def test_dlss_install_lays_out_exactly_what_build_rs_needs(self): + root = airdef.install_dlss_sdk() + self.assertEqual(root, self.dlss_cache / "v310.9.16") + expected = ["include/nvsdk_ngx.h", "include/nvsdk_ngx_helpers_vk.h", + *airdef.DLSS_LIBS, airdef.DLSS_RUNTIME] + for rel in expected: + self.assertTrue((root / rel).is_file(), rel) + marker = json.loads((root / airdef.INSTALL_MARKER).read_text(encoding="utf-8")) + self.assertEqual(marker["tag"], "v310.9.16") + self.assertEqual(marker["dll_bytes"], 24) + self.assertEqual(len(self.downloads), len(expected)) + self.assertTrue(all("/v310.9.16/" in url for url, _ in self.downloads)) + self.assertEqual([p.name for p in self.dlss_cache.iterdir()], ["v310.9.16"]) + + def test_second_install_is_a_cache_hit_without_downloads(self): + first = airdef.install_dlss_sdk() + count = len(self.downloads) + out = io.StringIO() + with contextlib.redirect_stdout(out): + second = airdef.install_dlss_sdk() + self.assertEqual(first, second) + self.assertEqual(len(self.downloads), count) + self.assertIn("кэше", out.getvalue()) + + def test_failed_download_removes_staging_and_installs_nothing(self): + dll_url = airdef.DLSS_RAW.format(tag="v310.9.16", path=airdef.DLSS_RUNTIME) + self.offline.add(dll_url) + with contextlib.redirect_stdout(io.StringIO()): + with self.assertRaises(airdef.DownloadError): + airdef.install_dlss_sdk() + self.assertFalse((self.dlss_cache / "v310.9.16").exists()) + self.assertEqual([p.name for p in self.dlss_cache.iterdir()], []) + + def test_damaged_cache_is_reinstalled(self): + root = airdef.install_dlss_sdk() + (root / airdef.DLSS_RUNTIME).unlink() + count = len(self.downloads) + with contextlib.redirect_stdout(io.StringIO()): + airdef.install_dlss_sdk() + self.assertTrue((root / airdef.DLSS_RUNTIME).is_file()) + self.assertGreater(len(self.downloads), count) + + def test_vulkan_headers_land_under_capital_include(self): + root = airdef.install_vulkan_headers() + self.assertEqual(root, self.vulkan_cache / airdef.VULKAN_TAG_PINNED) + self.assertTrue((root / "Include" / "vulkan" / "vulkan.h").is_file()) + self.assertTrue((root / "Include" / "vk_video" / "vulkan_video_codecs_common.h").is_file()) + self.assertTrue((root / airdef.INSTALL_MARKER).is_file()) + count = len(self.downloads) + with contextlib.redirect_stdout(io.StringIO()): + self.assertEqual(airdef.install_vulkan_headers(), root) + self.assertEqual(len(self.downloads), count) + + +class DlssBuildPlanTests(unittest.TestCase): + """План сборки: автоскачивание, приоритет явных переменных и деградация до mods.""" + + def setUp(self): + self.tmp = tempfile.TemporaryDirectory(prefix="airdef-dlss-plan-") + self.addCleanup(self.tmp.cleanup) + self.root = Path(self.tmp.name) + self.sdk = self.root / "DLSS" + (self.sdk / "include").mkdir(parents=True) + (self.sdk / "include" / "nvsdk_ngx.h").write_text("") + (self.sdk / "lib" / "Windows_x86_64" / "x64").mkdir(parents=True) + (self.sdk / airdef.DLSS_RUNTIME).parent.mkdir(parents=True) + (self.sdk / airdef.DLSS_RUNTIME).write_bytes(b"dll") + self.vulkan = self.root / "VulkanSDK" + (self.vulkan / "Include" / "vulkan").mkdir(parents=True) + (self.vulkan / "Include" / "vulkan" / "vulkan.h").write_text("") + + def plan(self, env=None, **kwargs): + out = io.StringIO() + baseline = {"DLSS_SDK": "", "VULKAN_SDK": "", "AIRDEF_GAME": ""} + baseline.update(env or {}) + with patch.dict(os.environ, baseline), contextlib.redirect_stdout(out): + return airdef.dlss_build_plan(**kwargs), out.getvalue() + + def test_non_windows_never_downloads(self): + with patch.object(airdef, "install_dlss_sdk", side_effect=AssertionError("download attempted")), \ + patch.object(airdef, "install_vulkan_headers", side_effect=AssertionError("download attempted")): + plan, output = self.plan(system="Darwin", gpus=["NVIDIA GeForce RTX 3060"]) + self.assertEqual(plan["features"], "mods") + self.assertEqual(plan["env"], {}) + self.assertEqual(output, "") + + def test_windows_without_rtx_never_downloads(self): + with patch.object(airdef, "install_dlss_sdk", side_effect=AssertionError("download attempted")), \ + patch.object(airdef, "install_vulkan_headers", side_effect=AssertionError("download attempted")): + plan, output = self.plan(system="Windows", gpus=["Intel(R) UHD Graphics 770"]) + self.assertEqual(plan["features"], "mods") + self.assertEqual(output, "") + + def test_windows_rtx_auto_installs_and_wires_env(self): + with patch.object(airdef, "dlss_sdk_path", return_value=None), \ + patch.object(airdef, "cached_dlss_sdk", return_value=None), \ + patch.object(airdef, "cached_vulkan_headers", return_value=None), \ + patch.object(airdef, "install_dlss_sdk", return_value=self.sdk) as dlss_install, \ + patch.object(airdef, "install_vulkan_headers", return_value=self.vulkan) as vulkan_install: + plan, output = self.plan(system="Windows", gpus=["NVIDIA GeForce RTX 3060"]) + dlss_install.assert_called_once_with() + vulkan_install.assert_called_once_with() + self.assertEqual(plan["features"], "mods,dlss") + self.assertEqual(plan["env"], {"DLSS_SDK": str(self.sdk), "VULKAN_SDK": str(self.vulkan)}) + self.assertEqual(plan["sdk"], self.sdk) + self.assertEqual(plan["dll"], self.sdk / airdef.DLSS_RUNTIME) + self.assertIn("mods,dlss", output) + + def test_install_failure_degrades_to_mods_with_warning(self): + with patch.object(airdef, "dlss_sdk_path", return_value=None), \ + patch.object(airdef, "cached_dlss_sdk", return_value=None), \ + patch.object(airdef, "cached_vulkan_headers", return_value=None), \ + patch.object(airdef, "install_dlss_sdk", side_effect=airdef.DownloadError("нет сети")), \ + patch.object(airdef, "install_vulkan_headers", return_value=self.vulkan): + plan, output = self.plan(system="Windows", gpus=["NVIDIA GeForce RTX 3060"]) + self.assertEqual(plan["features"], "mods") + self.assertEqual(plan["env"], {}) + self.assertIsNone(plan["sdk"]) + self.assertIn("не скачался", output) + self.assertIn("нет сети", output) + self.assertIn("TAAU", output) + + def test_explicit_env_wins_and_skips_download(self): + env = {"DLSS_SDK": str(self.sdk), "VULKAN_SDK": str(self.vulkan)} + with patch.object(airdef, "install_dlss_sdk", side_effect=AssertionError("download attempted")), \ + patch.object(airdef, "install_vulkan_headers", side_effect=AssertionError("download attempted")): + plan, _ = self.plan(env=env, system="Windows", gpus=["NVIDIA GeForce RTX 3060"]) + self.assertEqual(plan["features"], "mods,dlss") + self.assertEqual(plan["env"], env) + self.assertEqual(plan["sdk"], self.sdk) + + def test_explicit_but_invalid_env_does_not_silently_download(self): + env = {"DLSS_SDK": str(self.root / "missing"), "VULKAN_SDK": str(self.vulkan)} + with patch.object(airdef, "install_dlss_sdk", side_effect=AssertionError("download attempted")): + plan, output = self.plan(env=env, system="Windows", gpus=["NVIDIA GeForce RTX 3060"]) + self.assertEqual(plan["features"], "mods") + self.assertIn("путь неполный", output) + + def test_cached_sdk_is_used_without_download(self): + with patch.object(airdef, "dlss_sdk_path", return_value=None), \ + patch.object(airdef, "cached_dlss_sdk", return_value=self.sdk), \ + patch.object(airdef, "cached_vulkan_headers", return_value=self.vulkan), \ + patch.object(airdef, "install_dlss_sdk", side_effect=AssertionError("download attempted")), \ + patch.object(airdef, "install_vulkan_headers", side_effect=AssertionError("download attempted")): + plan, _ = self.plan(system="Windows", gpus=["NVIDIA GeForce RTX 3060"]) + self.assertEqual(plan["features"], "mods,dlss") + self.assertEqual(plan["sdk"], self.sdk) + + def test_game_passes_env_and_copies_dll_after_success(self): + plan = {"features": "mods,dlss", "env": {"DLSS_SDK": str(self.sdk), "VULKAN_SDK": str(self.vulkan)}, + "sdk": self.sdk, "dll": self.sdk / airdef.DLSS_RUNTIME} + calls = [] + + def fake_run(cmd, cwd=None, env=None): + calls.append({"cmd": cmd, "cwd": cwd, "env": env}) + + with patch.object(airdef, "fork"), patch.object(airdef, "cargo", return_value="cargo"), \ + patch.object(airdef, "dlss_build_plan", return_value=plan), \ + patch.object(airdef, "run", side_effect=fake_run), \ + patch.object(airdef, "place_dlss_runtime") as place: + airdef.game() + self.assertEqual(calls[0]["cmd"][-1], "mods,dlss") + self.assertEqual(calls[0]["env"]["DLSS_SDK"], str(self.sdk)) + self.assertEqual(calls[0]["env"]["VULKAN_SDK"], str(self.vulkan)) + place.assert_called_once_with(self.sdk) + + def test_game_without_dlss_does_not_touch_the_runtime_dll(self): + plan = {"features": "mods", "env": {}, "sdk": None, "dll": None} + with patch.object(airdef, "fork"), patch.object(airdef, "cargo", return_value="cargo"), \ + patch.object(airdef, "dlss_build_plan", return_value=plan), \ + patch.object(airdef, "run"), patch.object(airdef, "place_dlss_runtime") as place: + airdef.game() + place.assert_not_called() + + +class PlaceDlssRuntimeTests(unittest.TestCase): + """nvngx_dlss.dll кладётся рядом с собранным клиентом; без клиента — только предупреждение.""" + + def setUp(self): + self.tmp = tempfile.TemporaryDirectory(prefix="airdef-dlss-place-") + self.addCleanup(self.tmp.cleanup) + self.root = Path(self.tmp.name) + self.fork = self.root / "horizon" + self.sdk = self.root / "DLSS" + (self.sdk / airdef.DLSS_RUNTIME).parent.mkdir(parents=True) + (self.sdk / airdef.DLSS_RUNTIME).write_bytes(b"fresh-dlss-dll") + self.patches = [ + patch.object(airdef, "ROOT", self.root), + patch.object(airdef, "FORK", self.fork), + patch.dict(os.environ, {"AIRDEF_GAME": ""}), + ] + for item in self.patches: + item.start() + self.addCleanup(item.stop) + + def build(self): + exe = self.fork / "target" / "fast" / ("horizon-client" + airdef.EXE) + exe.parent.mkdir(parents=True) + exe.write_bytes(b"exe") + return exe + + def test_dll_lands_beside_the_built_client(self): + exe = self.build() + out = io.StringIO() + with contextlib.redirect_stdout(out): + target = airdef.place_dlss_runtime(self.sdk) + self.assertEqual(target, exe.with_name("nvngx_dlss.dll")) + self.assertEqual(target.read_bytes(), b"fresh-dlss-dll") + self.assertIn("nvngx_dlss.dll", out.getvalue()) + + def test_stale_dll_is_replaced_by_the_fresh_one(self): + exe = self.build() + target = exe.with_name("nvngx_dlss.dll") + target.write_bytes(b"stale-dll-here") + with contextlib.redirect_stdout(io.StringIO()): + airdef.place_dlss_runtime(self.sdk) + self.assertEqual(target.read_bytes(), b"fresh-dlss-dll") + + def test_missing_client_warns_instead_of_failing(self): + out = io.StringIO() + with contextlib.redirect_stdout(out): + self.assertIsNone(airdef.place_dlss_runtime(self.sdk)) + self.assertIn("вручную", out.getvalue()) + + if __name__ == "__main__": unittest.main()