mirror of
https://github.com/valentderah/totk-pc-recomp.git
synced 2026-11-18 20:15:56 +00:00
The branch forked 79 commits before main and 98 before dev. Resolutions: 1. Aspect ratio: dev's implementation stays (camera patch at page +56 on 1.4.3, tools/ultrawide_layout.py layouts per size in romfs-patches-<w>x<h>, the aspect = fit|stretch setting). The PR's second implementation is dropped: the aspect sets of patches-v121.txt and patches-v143.txt (the 1.4.3 one patched the same viewport sites as dev's), tools/aspect_layouts.py, the resolution.c shapes that limited game resolutions to 16:9, 16:10 and 21:9, and the picture_fit setting. Its letterbox code (gfx_fit_rect) is kept and reads TOTK_ASPECT. 2. Code dev changed where the PR moved it: the stick dead zone, the test gamepad and the paddles go to input.c; the DPI awareness, keep-awake and IME detach of gfx_window.c go to gfx_window_win.c; device fault reports and GPU breadcrumbs to gfx_present.c. gfx_window_dpi gets an SDL version. 3. dev's Win32 calls in shared code go through platform.h: the shader cache pack reader (PlatFile), the romfs overlay checks, the audio pacing waits, the motion, ASTC and device fault locks. plat_cpu_usable and plat_commit_info get Linux versions; plat_cpu_count counts the machine's processors on both. dpi_probe.c becomes dpi_probe_win.c. 4. assume_focus defaults to 1 as the PR has it (a load interrupted by a focus loss can stop for good) and stays live, with dev's Game tab row. 5. The frame limits 40 and 45 join dev's list. The BC 3D storage fallback for Vega only runs with TOTK_BLOCK_VIEWS_3D=1, since dev makes 3D BC images without block views by default. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
113 lines
5.7 KiB
Python
113 lines
5.7 KiB
Python
"""Package a built totk.exe into a folder that runs from anywhere: build/<version>-portable by default.
|
|
|
|
The folder holds the exe, its DLLs, the shader translator (NativeAOT: no .NET), the RomFS index and patches, the
|
|
extracted ExeFS (the game code the exe loads), the shared fonts, the prepared shader and pipeline files. There is
|
|
no config file: totk.exe finds the exefs, romfs, profile and shared-fonts folders next to itself. Without --with-romfs
|
|
the 16 GB RomFS image stays out; copy build/extracted/<version>/romfs/romfs.bin to <folder>/romfs/ or set TOTK_ROMFS
|
|
(a path, relative ones to the exe's folder).
|
|
|
|
The folder contains game code and data derived from the game: for your own machines only, never publish or share it.
|
|
Saves go to <folder>/profile.
|
|
|
|
.venv/Scripts/python tools/package_build.py [--version v121] [--build build/v121] [--exe PATH/totk.exe]
|
|
[--out build/v121-portable] [--with-romfs] [--no-shader-cache]
|
|
"""
|
|
import argparse
|
|
import os
|
|
import shutil
|
|
import sys
|
|
from concurrent.futures import ThreadPoolExecutor
|
|
from pathlib import Path
|
|
|
|
ROOT = Path(__file__).resolve().parent.parent
|
|
EXE = '.exe' if os.name == 'nt' else ''
|
|
# A Linux source build links the system's SDL3, Opus and libvpx: the other machine needs them installed
|
|
DLLS = ('SDL3.dll', 'libopus-0.dll', 'libiconv-2.dll') if os.name == 'nt' else ()
|
|
# Prepared state next to the exe: translator answers, programs, the prepared list, pipeline cache and its keys, and the
|
|
# variant lists `totk.exe --prepare-shaders` reads (the driver keys its library cache by exe path, so each copy runs it).
|
|
STATE = ('romfs-index.bin', 'pipeline-cache.bin', 'pipeline-keys.bin', 'shader-answers.bin', 'shader-programs.bin',
|
|
'shader-prepared.bin', 'seed-answers.bin', 'seed-programs.bin')
|
|
|
|
def copy(src, dst):
|
|
dst.parent.mkdir(parents=True, exist_ok=True)
|
|
shutil.copy2(src, dst)
|
|
|
|
|
|
def copy_tree(src, dst, workers=16):
|
|
jobs = []
|
|
for dirpath, _, files in os.walk(src):
|
|
rel = Path(dirpath).relative_to(src)
|
|
(dst / rel).mkdir(parents=True, exist_ok=True)
|
|
jobs += [(Path(dirpath) / f, dst / rel / f) for f in files if not f.endswith('.tmp')]
|
|
with ThreadPoolExecutor(workers) as pool:
|
|
list(pool.map(lambda j: shutil.copy2(*j), jobs))
|
|
return len(jobs)
|
|
|
|
|
|
def size_of(path):
|
|
return sum(f.stat().st_size for f in Path(path).rglob('*') if f.is_file())
|
|
|
|
|
|
def main():
|
|
ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
|
|
ap.add_argument('--version', default='v121', help='game version (v121 or v143): the defaults below follow it')
|
|
ap.add_argument('--build', type=Path, help='build dir with the prepared state (default build/<version>)')
|
|
ap.add_argument('--exe', type=Path, help='totk.exe to package (default: <build>/totk.exe); its DLLs are taken from --build')
|
|
ap.add_argument('--xlate', type=Path, default=ROOT / 'build' / 'xlate' / f'totk_xlate{EXE}')
|
|
ap.add_argument('--extracted', type=Path, help='default build/extracted/<version>')
|
|
ap.add_argument('--out', type=Path, help='default build/<version>-portable')
|
|
ap.add_argument('--with-romfs', action='store_true', help='also copy romfs.bin (about 16 GB)')
|
|
ap.add_argument('--no-shader-cache', action='store_true', help='leave out shader-cache (about 2 GB): translates again')
|
|
a = ap.parse_args()
|
|
a.build = a.build or ROOT / 'build' / a.version
|
|
a.extracted = a.extracted or ROOT / 'build' / 'extracted' / a.version
|
|
a.out = a.out or ROOT / 'build' / f'{a.version}-portable'
|
|
|
|
build, out = a.build.resolve(), a.out.resolve()
|
|
exe = (a.exe or build / f'totk{EXE}').resolve()
|
|
fonts = a.extracted.resolve().parent / 'firmware' / 'shared-fonts'
|
|
exefs = a.extracted.resolve() / 'exefs'
|
|
romfs = a.extracted.resolve() / 'romfs' / 'romfs.bin'
|
|
need = [exe, a.xlate, exefs, fonts, build / 'romfs-patches'] + [build / d for d in DLLS] + [build / 'romfs-index.bin']
|
|
if a.with_romfs:
|
|
need.append(romfs)
|
|
missing = [str(p) for p in need if not p.exists()]
|
|
if missing:
|
|
sys.exit('package_build: missing: ' + ', '.join(missing))
|
|
if out == build:
|
|
sys.exit('package_build: --out must not be the build dir')
|
|
if not str(out).startswith(str(ROOT / 'build')) and not str(out).startswith(str(ROOT / 'generated')):
|
|
print('package_build: warning: the folder holds game code; keep it out of the repository')
|
|
|
|
out.mkdir(parents=True, exist_ok=True)
|
|
copy(exe, out / f'totk{EXE}')
|
|
for d in DLLS:
|
|
copy(build / d, out / d)
|
|
copy(a.xlate, out / f'totk_xlate{EXE}')
|
|
idf = a.xlate.with_suffix('.id')
|
|
if idf.exists():
|
|
copy(idf, out / 'totk_xlate.id')
|
|
for f in STATE:
|
|
if (build / f).exists():
|
|
copy(build / f, out / f)
|
|
else:
|
|
print(f'package_build: {f} not in {build}, skipped')
|
|
n = copy_tree(build / 'romfs-patches', out / 'romfs-patches')
|
|
if (build / 'romfs-patches-xbox').is_dir(): # pad_layout = xbox_prompts (make_romfs_patches.py --xbox-prompts)
|
|
n += copy_tree(build / 'romfs-patches-xbox', out / 'romfs-patches-xbox')
|
|
n += copy_tree(exefs, out / 'exefs')
|
|
n += copy_tree(fonts, out / 'shared-fonts')
|
|
if not a.no_shader_cache and (build / 'shader-cache').is_dir():
|
|
n += copy_tree(build / 'shader-cache', out / 'shader-cache')
|
|
(out / 'profile').mkdir(exist_ok=True)
|
|
if a.with_romfs:
|
|
(out / 'romfs').mkdir(exist_ok=True)
|
|
print('package_build: copying romfs.bin (16 GB) ...')
|
|
shutil.copyfile(romfs, out / 'romfs' / 'romfs.bin')
|
|
print(f'package_build: {out}: {n} files in folders, {size_of(out) / 2**30:.2f} GiB'
|
|
+ ('' if a.with_romfs else f'; no RomFS: put romfs.bin into romfs{os.sep} or set TOTK_ROMFS'))
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|