diff --git a/tools/airdef.py b/tools/airdef.py index b119a19..ab68a77 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 + python3 tools/airdef.py game # собрать игру (форк) — нужен Rust; на Windows + NVIDIA RTX сам скачивает DLSS SDK, Vulkan-заголовки и libclang python3 tools/airdef.py mod # собрать мод airdef.hmod — нужен Rust с wasm32 python3 tools/airdef.py install # положить мод в папку игры и включить python3 tools/airdef.py play [аргументы игры] # запустить форк на папке игры @@ -13,9 +13,10 @@ Переменные окружения: HORIZON_HOME (папка игры), HORIZON_RESOURCES (подготовленные ресурсы 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. +На Windows + NVIDIA RTX сборка с DLSS (feature dlss) сама скачивает DLSS SDK, заголовки Vulkan и +libclang для bindgen в .horizon-cache/ и кладёт nvngx_dlss.dll рядом с horizon-client.exe. Явные +DLSS_SDK, VULKAN_SDK и LIBCLANG_PATH по-прежнему имеют приоритет над автоскачиванием; при сбое сети +собирается обычный mods/TAAU. """ import glob import hashlib @@ -139,9 +140,19 @@ VULKAN_HEADERS = ( "vk_video/vulkan_video_codec_vp9std_decode.h", "vk_video/vulkan_video_codecs_common.h", ) +# bindgen из dlss_wgpu ищет libclang.dll; в DLSS SDK и Vulkan-заголовках его нет. +LIBCLANG_NUGET = "libclang.runtime.win-x64" +LIBCLANG_INDEX = "https://api.nuget.org/v3-flatcontainer/libclang.runtime.win-x64/index.json" +LIBCLANG_PACKAGE = ("https://api.nuget.org/v3-flatcontainer/libclang.runtime.win-x64/{version}/" + "libclang.runtime.win-x64.{version}.nupkg") +LIBCLANG_VERSION_PINNED = "23.1.5" +LIBCLANG_NATIVE = "runtimes/win-x64/native/libclang.dll" +LIBCLANG_URL = "https://www.nuget.org/packages/libclang.runtime.win-x64" + CACHE = ROOT / ".horizon-cache" DLSS_CACHE = CACHE / "dlss-sdk" VULKAN_CACHE = CACHE / "vulkan-headers" +LIBCLANG_CACHE = CACHE / "libclang" INSTALL_MARKER = "airdef-install.json" @@ -154,7 +165,8 @@ def open_url(url): return urllib.request.urlopen(request, timeout=120) -def github_json(url): +def fetch_json(url): + """JSON с GitHub API или nuget.org: общий транспорт для версий и списков файлов.""" with open_url(url) as response: return json.load(response) @@ -195,7 +207,7 @@ def download(url, dest): def dlss_latest_tag(): """Новейший стабильный тег v310.9.x с GitHub; при сбое API — закреплённый v310.9.1.""" try: - tags = github_json(DLSS_TAGS_API) + tags = fetch_json(DLSS_TAGS_API) except Exception as exc: print(f"Внимание: не удалось получить теги DLSS ({exc}); беру {DLSS_TAG_PINNED}.", flush=True) return DLSS_TAG_PINNED @@ -214,7 +226,7 @@ def dlss_latest_tag(): 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}") + entries = fetch_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: @@ -333,6 +345,132 @@ def install_vulkan_headers(tag=VULKAN_TAG_PINNED): return dest +def version_key(text): + """Числовой ключ версии NuGet: 23.1.10 новее 23.1.5 (строкой было бы наоборот).""" + numbers = tuple(int(part) for part in re.findall(r"\d+", str(text))) + return numbers or (0,) + + +def libclang_root(path): + """Каталог, в котором bindgen найдёт libclang.dll (или clang.dll), либо None.""" + if not path: + return None + path = Path(path) + return path if any((path / name).is_file() for name in ("libclang.dll", "clang.dll")) else None + + +def vs_libclang(): + """LLVM из Visual Studio (VC\\Tools\\Llvm\\x64\\bin) через vswhere; вне Windows — None.""" + if platform.system() != "Windows": + return None + base = os.environ.get("ProgramFiles(x86)") or os.environ.get("ProgramFiles") + vswhere = Path(base) / "Microsoft Visual Studio" / "Installer" / "vswhere.exe" if base else None + if vswhere is None or not vswhere.is_file(): + return None + flags = getattr(subprocess, "CREATE_NO_WINDOW", 0) + try: + out = subprocess.run([str(vswhere), "-products", "*", "-latest", + "-find", "VC\\Tools\\Llvm\\x64\\bin\\libclang.dll"], + capture_output=True, text=True, timeout=30, + creationflags=flags, errors="replace") + except (OSError, ValueError, subprocess.SubprocessError): + return None + for line in out.stdout.splitlines(): + found = libclang_root(Path(line.strip()).parent) + if found: + return found + return None + + +def system_libclang(): + """Уже установленный libclang: PATH, Program Files\\LLVM\\bin, LLVM из Visual Studio.""" + for entry in os.environ.get("PATH", "").split(os.pathsep): + found = libclang_root(entry) + if found: + return found + for env in ("ProgramFiles", "ProgramFiles(x86)"): + if os.environ.get(env): + found = libclang_root(Path(os.environ[env]) / "LLVM" / "bin") + if found: + return found + return vs_libclang() + + +def libclang_latest_version(): + """Последняя стабильная версия libclang.runtime.win-x64 с NuGet; pinned при сбое API.""" + try: + data = fetch_json(LIBCLANG_INDEX) + versions = [v for v in data.get("versions", []) + if isinstance(v, str) and "-" not in v and version_key(v) != (0,)] + except Exception as exc: + print(f"Внимание: не удалось получить версии libclang ({exc}); беру {LIBCLANG_VERSION_PINNED}.", + flush=True) + return LIBCLANG_VERSION_PINNED + if not versions: + print(f"Внимание: NuGet не вернул стабильные версии libclang; беру {LIBCLANG_VERSION_PINNED}.", + flush=True) + return LIBCLANG_VERSION_PINNED + return max(versions, key=version_key) + + +def libclang_cache_ok(path, version): + """Кэш libclang: маркер этой версии и DLL того же размера (иначе — перекачать).""" + state = read_marker(path) + dll = Path(path) / "libclang.dll" + return bool(state) and state.get("tag") == version and dll.is_file() \ + and state.get("dll_bytes") == dll.stat().st_size + + +def cached_libclang(): + try: + candidates = sorted(LIBCLANG_CACHE.iterdir(), key=lambda p: version_key(p.name), reverse=True) + except OSError: + return None + for path in candidates: + if libclang_cache_ok(path, path.name): + return path + return None + + +def install_libclang(version=None): + """libclang.dll из NuGet-пакета libclang.runtime.win-x64 в .horizon-cache/libclang/. + + Пакет (~34 МБ) распаковывается выборочно: нужен только runtimes/win-x64/native/libclang.dll. + """ + version = version or libclang_latest_version() + dest = LIBCLANG_CACHE / version + if libclang_cache_ok(dest, version): + print(f"libclang {version}: уже в кэше {dest}", flush=True) + return dest + url = LIBCLANG_PACKAGE.format(version=version) + print(f"libclang {version}: скачиваю {LIBCLANG_NUGET} (~34 МБ) с nuget.org", flush=True) + staging = LIBCLANG_CACHE / f".{version}.part" + shutil.rmtree(staging, ignore_errors=True) + package = staging / f"libclang.runtime.win-x64.{version}.nupkg" + try: + download(url, package) + with zipfile.ZipFile(package) as archive: + with archive.open(LIBCLANG_NATIVE) as src, open(staging / "libclang.dll", "wb") as out: + shutil.copyfileobj(src, out) + package.unlink() + dll = staging / "libclang.dll" + if not dll.is_file() or dll.stat().st_size == 0: + raise DownloadError(f"libclang {version}: в пакете нет {LIBCLANG_NATIVE}") + (staging / INSTALL_MARKER).write_text(json.dumps({ + "tag": version, "source": LIBCLANG_URL, + "dll_bytes": dll.stat().st_size}, indent=2) + "\n", encoding="utf-8") + shutil.rmtree(dest, ignore_errors=True) + staging.rename(dest) + except (KeyError, zipfile.BadZipFile) as exc: + shutil.rmtree(staging, ignore_errors=True) + raise DownloadError(f"libclang {version}: {exc}") from exc + except Exception: + shutil.rmtree(staging, ignore_errors=True) + raise + print(f"libclang {version}: готов, {dest / 'libclang.dll'}", flush=True) + return dest + + def gpu_names(): """Имена видеоадаптеров Windows. Сбой опроса — пустой список (это «нет DLSS», а не ошибка сборки).""" if platform.system() != "Windows": @@ -391,11 +529,12 @@ def _auto_install(install, label): def dlss_build_plan(system=None, gpus=None, sdk=None) -> dict: - """Features сборки и окружение DLSS_SDK/VULKAN_SDK для Windows + NVIDIA RTX. + """Features сборки и окружение DLSS_SDK/VULKAN_SDK/LIBCLANG_PATH для Windows + NVIDIA RTX. Возвращает {"features", "env", "sdk", "dll"}. Без явного SDK на Windows + RTX сам скачивает - DLSS SDK и заголовки Vulkan в .horizon-cache. Явные DLSS_SDK/VULKAN_SDK (или аргумент sdk) - имеют приоритет и отключают автоскачивание; неполный явный путь — предупреждение и mods. + DLSS SDK, заголовки Vulkan и libclang для bindgen в .horizon-cache. Явные + DLSS_SDK/VULKAN_SDK/LIBCLANG_PATH (или аргумент sdk) имеют приоритет и отключают автоскачивание + своего компонента; неполный явный путь — предупреждение и mods. """ plan = {"features": "mods", "env": {}, "sdk": None, "dll": None} system = platform.system() if system is None else system @@ -427,27 +566,51 @@ def dlss_build_plan(system=None, gpus=None, sdk=None) -> dict: if vulkan_root is None: vulkan_root = _auto_install(install_vulkan_headers, "Vulkan-заголовки") + # libclang нужен только bindgen'у из dlss_wgpu, поэтому качаем его лишь когда SDK и Vulkan уже есть. + env_libclang = os.environ.get("LIBCLANG_PATH") + explicit_libclang = bool(env_libclang) + clang_root = None + if sdk_root is not None and vulkan_root is not None: + if env_libclang: + clang_root = libclang_root(env_libclang) + else: + clang_root = system_libclang() or cached_libclang() + if clang_root is None: + clang_root = _auto_install(install_libclang, "libclang для bindgen") + missing = [] if sdk_root is None: missing.append("NVIDIA DLSS SDK") if vulkan_root is None: missing.append("заголовки Vulkan") + if sdk_root is not None and vulkan_root is not None and clang_root is None: + missing.append("libclang для bindgen") if missing: print("Внимание: NVIDIA RTX найден, но DLSS-сборка пропущена — нет " + " и ".join(missing) + ".", flush=True) - if explicit_sdk or explicit_vulkan: - print(" DLSS_SDK/VULKAN_SDK заданы, но путь неполный. Убери их, и airdef.py скачает SDK сам.", + incomplete = [] + if explicit_sdk and sdk_root is None: + incomplete.append("DLSS_SDK") + if explicit_vulkan and vulkan_root is None: + incomplete.append("VULKAN_SDK") + if explicit_libclang and clang_root is None and sdk_root is not None and vulkan_root is not None: + incomplete.append("LIBCLANG_PATH") + if incomplete: + print(f" {', '.join(incomplete)}: путь неполный. Убери переменную, и airdef.py скачает всё сам.", 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) + f"заголовки (VULKAN_SDK, {VULKAN_SDK_URL}); libclang — winget install LLVM.LLVM " + "(переменная LIBCLANG_PATH).", flush=True) print(" Собираю --features mods: DLSS выключен, native TAAU остаётся.", flush=True) 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) + env={"DLSS_SDK": str(sdk_root), "VULKAN_SDK": str(vulkan_root), + "LIBCLANG_PATH": str(clang_root)}) + print(f"DLSS: NVIDIA RTX, SDK {sdk_root}, libclang {clang_root}; собираю --features mods,dlss", + flush=True) print(" nvngx_dlss.dll из SDK кладу рядом с horizon-client.exe после сборки; DLSS включён по умолчанию — переключатель в настройках мода (N → DLSS), HORIZON_DLSS=1|0 переопределяет.", flush=True) return plan diff --git a/tools/test_airdef_build.py b/tools/test_airdef_build.py index d7f79a9..fa2c805 100644 --- a/tools/test_airdef_build.py +++ b/tools/test_airdef_build.py @@ -8,7 +8,8 @@ from pathlib import Path import subprocess import tempfile import unittest -from unittest.mock import patch +import zipfile +from unittest.mock import Mock, patch SPEC = importlib.util.spec_from_file_location("airdef_build", Path(__file__).with_name("airdef.py")) airdef = importlib.util.module_from_spec(SPEC) @@ -75,14 +76,21 @@ class DlssBuildFeatureTests(unittest.TestCase): self.vulkan = self.root / "VulkanSDK" (self.vulkan / "Include" / "vulkan").mkdir(parents=True) (self.vulkan / "Include" / "vulkan" / "vulkan.h").write_text("") + self.libclang = self.root / "LLVM" / "bin" + self.libclang.mkdir(parents=True) + (self.libclang / "libclang.dll").write_bytes(b"clang") + self.libclang_patch = patch.object(airdef, "system_libclang", return_value=self.libclang) + self.libclang_patch.start() def tearDown(self): + self.libclang_patch.stop() self.tmp.cleanup() def features(self, **kwargs): out = io.StringIO() # Пустые DLSS_SDK/VULKAN_SDK — «не заданы»: автоскачивание в этих тестах не нужно. - with patch.dict(os.environ, {"VULKAN_SDK": str(self.vulkan), "DLSS_SDK": ""}), \ + with patch.dict(os.environ, {"VULKAN_SDK": str(self.vulkan), "DLSS_SDK": "", + "LIBCLANG_PATH": ""}), \ contextlib.redirect_stdout(out): return airdef.dlss_build_features(**kwargs), out.getvalue() @@ -189,23 +197,23 @@ class DlssVersionTests(unittest.TestCase): 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()): + with patch.object(airdef, "fetch_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")), \ + with patch.object(airdef, "fetch_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): + with patch.object(airdef, "fetch_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")): + with patch.object(airdef, "fetch_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) @@ -301,6 +309,151 @@ class DlssAutoInstallTests(unittest.TestCase): self.assertEqual(len(self.downloads), count) +class LibclangDetectionTests(unittest.TestCase): + """Поиск уже установленного libclang: LIBCLANG_PATH, PATH, Program Files, vswhere.""" + + def setUp(self): + self.tmp = tempfile.TemporaryDirectory(prefix="airdef-libclang-detect-") + self.addCleanup(self.tmp.cleanup) + self.root = Path(self.tmp.name) + + def test_root_accepts_libclang_or_clang_dll_only(self): + for name in ("libclang.dll", "clang.dll"): + folder = self.root / name.replace(".", "_") + folder.mkdir() + (folder / name).write_bytes(b"dll") + self.assertEqual(airdef.libclang_root(folder), folder) + empty = self.root / "empty" + empty.mkdir() + self.assertIsNone(airdef.libclang_root(empty)) + self.assertIsNone(airdef.libclang_root("")) + + def test_path_entry_is_found(self): + folder = self.root / "bin" + folder.mkdir() + (folder / "libclang.dll").write_bytes(b"dll") + with patch.dict(os.environ, {"PATH": os.pathsep.join([str(self.root / "nothing"), str(folder)]), + "ProgramFiles": "", "ProgramFiles(x86)": ""}): + self.assertEqual(airdef.system_libclang(), folder) + + def test_program_files_llvm_install_is_found(self): + bin_dir = self.root / "LLVM" / "bin" + bin_dir.mkdir(parents=True) + (bin_dir / "libclang.dll").write_bytes(b"dll") + with patch.dict(os.environ, {"PATH": "", "ProgramFiles": str(self.root), "ProgramFiles(x86)": ""}): + self.assertEqual(airdef.system_libclang(), bin_dir) + + def test_visual_studio_llvm_is_found_through_vswhere(self): + bin_dir = self.root / "VC" / "Tools" / "Llvm" / "x64" / "bin" + bin_dir.mkdir(parents=True) + (bin_dir / "libclang.dll").write_bytes(b"dll") + vswhere = self.root / "Microsoft Visual Studio" / "Installer" / "vswhere.exe" + vswhere.parent.mkdir(parents=True) + vswhere.write_bytes(b"exe") + result = Mock(stdout=str(bin_dir / "libclang.dll") + "\n", returncode=0) + with patch.object(airdef.platform, "system", return_value="Windows"), \ + patch.dict(os.environ, {"PATH": "", "ProgramFiles": "", "ProgramFiles(x86)": str(self.root)}), \ + patch.object(airdef.subprocess, "run", return_value=result) as run: + self.assertEqual(airdef.system_libclang(), bin_dir) + self.assertIn("-find", run.call_args[0][0]) + + def test_no_install_anywhere_returns_none(self): + with patch.object(airdef.platform, "system", return_value="Windows"), \ + patch.dict(os.environ, {"PATH": "", "ProgramFiles": "", "ProgramFiles(x86)": ""}): + self.assertIsNone(airdef.system_libclang()) + + +class LibclangVersionTests(unittest.TestCase): + """Версия NuGet: числовой максимум без prerelease, при сбое API — pinned 23.1.5.""" + + def test_numeric_max_not_string_max(self): + data = {"versions": ["18.1.3.2", "23.1.5", "23.1.10", "24.0.0-preview", "junk"]} + with patch.object(airdef, "fetch_json", return_value=data), contextlib.redirect_stdout(io.StringIO()): + self.assertEqual(airdef.libclang_latest_version(), "23.1.10") + + def test_api_failure_falls_back_to_pinned(self): + out = io.StringIO() + with patch.object(airdef, "fetch_json", side_effect=OSError("offline")), \ + contextlib.redirect_stdout(out): + self.assertEqual(airdef.libclang_latest_version(), airdef.LIBCLANG_VERSION_PINNED) + self.assertIn(airdef.LIBCLANG_VERSION_PINNED, out.getvalue()) + + def test_empty_version_list_falls_back_to_pinned(self): + with patch.object(airdef, "fetch_json", return_value={"versions": []}), \ + contextlib.redirect_stdout(io.StringIO()): + self.assertEqual(airdef.libclang_latest_version(), airdef.LIBCLANG_VERSION_PINNED) + + +class LibclangAutoInstallTests(unittest.TestCase): + """NuGet-пакет: скачать, выборочно распаковать libclang.dll, кэш и повторное использование.""" + + def setUp(self): + self.tmp = tempfile.TemporaryDirectory(prefix="airdef-libclang-install-") + self.addCleanup(self.tmp.cleanup) + self.cache = Path(self.tmp.name) / "libclang" + self.downloads = [] + self.members = {airdef.LIBCLANG_NATIVE: b"clang-bytes"} + patches = [ + patch.object(airdef, "LIBCLANG_CACHE", self.cache), + patch.object(airdef, "libclang_latest_version", return_value="23.1.5"), + 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): + self.downloads.append((url, Path(dest))) + Path(dest).parent.mkdir(parents=True, exist_ok=True) + with zipfile.ZipFile(dest, "w") as archive: + for name, payload in self.members.items(): + archive.writestr(name, payload) + + def test_extracts_only_the_native_dll_and_writes_marker(self): + root = airdef.install_libclang() + self.assertEqual(root, self.cache / "23.1.5") + self.assertEqual((root / "libclang.dll").read_bytes(), b"clang-bytes") + marker = json.loads((root / airdef.INSTALL_MARKER).read_text(encoding="utf-8")) + self.assertEqual(marker["tag"], "23.1.5") + self.assertEqual(marker["dll_bytes"], len(b"clang-bytes")) + self.assertEqual(len(self.downloads), 1) + self.assertIn("/23.1.5/libclang.runtime.win-x64.23.1.5.nupkg", self.downloads[0][0]) + self.assertEqual([p.name for p in self.cache.iterdir()], ["23.1.5"]) + + def test_cache_hit_skips_download(self): + first = airdef.install_libclang() + out = io.StringIO() + with contextlib.redirect_stdout(out): + second = airdef.install_libclang() + self.assertEqual(first, second) + self.assertEqual(len(self.downloads), 1) + self.assertIn("кэше", out.getvalue()) + + def test_damaged_cache_is_reinstalled(self): + root = airdef.install_libclang() + (root / "libclang.dll").unlink() + with contextlib.redirect_stdout(io.StringIO()): + airdef.install_libclang() + self.assertTrue((root / "libclang.dll").is_file()) + self.assertEqual(len(self.downloads), 2) + + def test_package_without_the_native_dll_fails_cleanly(self): + self.members = {"runtimes/win-x64/native/other.dll": b"nope"} + with contextlib.redirect_stdout(io.StringIO()): + with self.assertRaises(airdef.DownloadError): + airdef.install_libclang() + self.assertFalse((self.cache / "23.1.5").exists()) + self.assertEqual([p.name for p in self.cache.iterdir()], []) + + def test_missing_cache_directory_is_not_an_error(self): + self.assertIsNone(airdef.cached_libclang()) + + def test_explicit_version_selects_the_package(self): + with contextlib.redirect_stdout(io.StringIO()): + airdef.install_libclang("23.1.4") + self.assertIn("/23.1.4/libclang.runtime.win-x64.23.1.4.nupkg", self.downloads[0][0]) + + class DlssBuildPlanTests(unittest.TestCase): """План сборки: автоскачивание, приоритет явных переменных и деградация до mods.""" @@ -317,10 +470,17 @@ class DlssBuildPlanTests(unittest.TestCase): self.vulkan = self.root / "VulkanSDK" (self.vulkan / "Include" / "vulkan").mkdir(parents=True) (self.vulkan / "Include" / "vulkan" / "vulkan.h").write_text("") + self.libclang = self.root / "LLVM" / "bin" + self.libclang.mkdir(parents=True) + (self.libclang / "libclang.dll").write_bytes(b"clang") + # Детект уже установленного libclang по умолчанию успешен: эти тесты не ходят в сеть. + detection = patch.object(airdef, "system_libclang", return_value=self.libclang) + detection.start() + self.addCleanup(detection.stop) def plan(self, env=None, **kwargs): out = io.StringIO() - baseline = {"DLSS_SDK": "", "VULKAN_SDK": "", "AIRDEF_GAME": ""} + baseline = {"DLSS_SDK": "", "VULKAN_SDK": "", "LIBCLANG_PATH": "", "AIRDEF_GAME": ""} baseline.update(env or {}) with patch.dict(os.environ, baseline), contextlib.redirect_stdout(out): return airdef.dlss_build_plan(**kwargs), out.getvalue() @@ -350,7 +510,8 @@ class DlssBuildPlanTests(unittest.TestCase): 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["env"], {"DLSS_SDK": str(self.sdk), "VULKAN_SDK": str(self.vulkan), + "LIBCLANG_PATH": str(self.libclang)}) self.assertEqual(plan["sdk"], self.sdk) self.assertEqual(plan["dll"], self.sdk / airdef.DLSS_RUNTIME) self.assertIn("mods,dlss", output) @@ -360,7 +521,8 @@ class DlssBuildPlanTests(unittest.TestCase): 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): + patch.object(airdef, "install_vulkan_headers", return_value=self.vulkan), \ + patch.object(airdef, "install_libclang", side_effect=AssertionError("libclang too early")): plan, output = self.plan(system="Windows", gpus=["NVIDIA GeForce RTX 3060"]) self.assertEqual(plan["features"], "mods") self.assertEqual(plan["env"], {}) @@ -370,9 +532,11 @@ class DlssBuildPlanTests(unittest.TestCase): self.assertIn("TAAU", output) def test_explicit_env_wins_and_skips_download(self): - env = {"DLSS_SDK": str(self.sdk), "VULKAN_SDK": str(self.vulkan)} + env = {"DLSS_SDK": str(self.sdk), "VULKAN_SDK": str(self.vulkan), + "LIBCLANG_PATH": str(self.libclang)} with patch.object(airdef, "install_dlss_sdk", side_effect=AssertionError("download attempted")), \ - patch.object(airdef, "install_vulkan_headers", side_effect=AssertionError("download attempted")): + patch.object(airdef, "install_vulkan_headers", side_effect=AssertionError("download attempted")), \ + patch.object(airdef, "system_libclang", side_effect=AssertionError("detection attempted")): plan, _ = self.plan(env=env, system="Windows", gpus=["NVIDIA GeForce RTX 3060"]) self.assertEqual(plan["features"], "mods,dlss") self.assertEqual(plan["env"], env) @@ -386,7 +550,8 @@ class DlssBuildPlanTests(unittest.TestCase): plan, _ = self.plan(env=env, system="Windows", gpus=["NVIDIA GeForce RTX 3060"]) 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["env"], {"DLSS_SDK": str(self.sdk), "VULKAN_SDK": str(self.vulkan), + "LIBCLANG_PATH": str(self.libclang)}) def test_explicit_but_invalid_env_does_not_silently_download(self): env = {"DLSS_SDK": str(self.root / "missing"), "VULKAN_SDK": str(self.vulkan)} @@ -405,8 +570,61 @@ class DlssBuildPlanTests(unittest.TestCase): self.assertEqual(plan["features"], "mods,dlss") self.assertEqual(plan["sdk"], self.sdk) + def test_libclang_auto_installed_when_not_found(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, "system_libclang", return_value=None), \ + patch.object(airdef, "cached_libclang", return_value=None), \ + patch.object(airdef, "install_libclang", return_value=self.libclang) as libclang_install: + plan, output = self.plan(system="Windows", gpus=["NVIDIA GeForce RTX 3060"]) + libclang_install.assert_called_once_with() + self.assertEqual(plan["features"], "mods,dlss") + self.assertEqual(plan["env"]["LIBCLANG_PATH"], str(self.libclang)) + self.assertIn("libclang", output) + + def test_libclang_failure_degrades_to_mods(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, "system_libclang", return_value=None), \ + patch.object(airdef, "cached_libclang", return_value=None), \ + patch.object(airdef, "install_libclang", + side_effect=airdef.DownloadError("нет nuget")): + plan, output = self.plan(system="Windows", gpus=["NVIDIA GeForce RTX 3060"]) + self.assertEqual(plan["features"], "mods") + self.assertEqual(plan["env"], {}) + self.assertIn("libclang", output) + self.assertIn("нет nuget", output) + self.assertIn("TAAU", output) + + def test_explicit_libclang_path_wins_and_skips_detection(self): + env = {"LIBCLANG_PATH": str(self.libclang)} + 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, "system_libclang", side_effect=AssertionError("detection attempted")), \ + patch.object(airdef, "install_libclang", 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"]["LIBCLANG_PATH"], str(self.libclang)) + + def test_explicit_invalid_libclang_env_does_not_download(self): + env = {"LIBCLANG_PATH": str(self.root / "missing")} + 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, "system_libclang", side_effect=AssertionError("detection attempted")), \ + patch.object(airdef, "install_libclang", 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("LIBCLANG_PATH", output) + self.assertIn("путь неполный", output) + 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)}, + plan = {"features": "mods,dlss", + "env": {"DLSS_SDK": str(self.sdk), "VULKAN_SDK": str(self.vulkan), + "LIBCLANG_PATH": str(self.libclang)}, "sdk": self.sdk, "dll": self.sdk / airdef.DLSS_RUNTIME} calls = [] @@ -421,6 +639,7 @@ class DlssBuildPlanTests(unittest.TestCase): 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)) + self.assertEqual(calls[0]["env"]["LIBCLANG_PATH"], str(self.libclang)) place.assert_called_once_with(self.sdk) def test_game_without_dlss_does_not_touch_the_runtime_dll(self):