mirror of
https://github.com/mitch030504/Wiicompiled_VR_Frame.git
synced 2026-10-06 01:00:14 +02:00
655 lines
37 KiB
PowerShell
655 lines
37 KiB
PowerShell
# The Quest game kit: everything libmain.so links except the translated game, plus the recipe
|
|
# that compiles and links the player's own translation against it.
|
|
#
|
|
# The APK never contains translated Mario Kart code. Its assets carry this kit instead, and the
|
|
# player's libmain.so is built from their own disc, either on the headset (the launcher's
|
|
# on-device builder) or on a PC (Build-QuestGame.ps1, the PC launcher's "Build for Quest"), then
|
|
# loaded from the app's private storage. Both builders replay one recipe, kit.json, which is
|
|
# exported from CMake's own build graph so its flags and link order cannot drift from a normal
|
|
# build:
|
|
#
|
|
# * the link line of the flavour's probe (runtime/cmake/PublicProducts.cmake), which is that
|
|
# product without any translated code, becomes kit.json's link inputs, with {game:*} markers
|
|
# where the game's objects sat in the product's own link;
|
|
# * the compile commands CMake recorded for one source of each generated kind (translated shard,
|
|
# registration shard, disc-generated runtime source, blob assembly) become kit.json's
|
|
# compile flags, with include paths reduced to the kit's copy of runtime/include;
|
|
# * kit.json's "sources" says which of the translator's build_shards lists fill each slot, so a
|
|
# builder never has to know which flavour it is building.
|
|
#
|
|
# Placeholders in kit.json: {kit} the extracted kit, {sysroot} the NDK sysroot the compiler
|
|
# uses, {workspace} the directory holding the translator's generated/ tree.
|
|
#
|
|
# Windows PowerShell 5.1 compatible.
|
|
|
|
Set-StrictMode -Version Latest
|
|
|
|
$script:KitSchema = 3
|
|
$script:GameSchema = 1
|
|
|
|
# What each app flavour's kit is made of. Slots name the game's objects in the probe's link line,
|
|
# and Sources says which of the translator's build_shards lists ("@NAME") or generated files fill
|
|
# each of them, in link order. Retro Rewind adds a slot: the mod's own shards and the
|
|
# profile-sensitive base shards it replaces the base flavour's with, linked as objects rather
|
|
# than through the base archive.
|
|
$script:KitProfiles = @{
|
|
base = @{
|
|
Probe = 'libmkw_quest_kit_probe'
|
|
ProductObjectPattern = '/base_product\.cpp\.o$'
|
|
RegistrationPattern = '/build_shards/base_registration/[^/]+\.cpp$'
|
|
Slots = @('runtime', 'product', 'translated')
|
|
Sources = [ordered]@{
|
|
runtime = @('{workspace}/generated/data_sections_init.cpp', '{workspace}/generated/guest_symbol_table.cpp',
|
|
'{workspace}/generated/data_sections_init_blobs.S')
|
|
product = @('@MKW_BASE_REGISTRATION_SOURCES')
|
|
translated = @('@MKW_BASE_COMMON_SHARDS', '@MKW_BASE_PORTABLE_SENSITIVE_SHARDS')
|
|
}
|
|
}
|
|
retro_rewind = @{
|
|
Probe = 'libmkw_quest_kit_probe_retro'
|
|
ProductObjectPattern = '/retro_rewind_product\.cpp\.o$'
|
|
RegistrationPattern = '/build_shards/retro_rewind_registration/[^/]+\.cpp$'
|
|
Slots = @('runtime', 'product', 'mod', 'translated')
|
|
Sources = [ordered]@{
|
|
runtime = @('{workspace}/generated/data_sections_init.cpp', '{workspace}/generated/guest_symbol_table.cpp',
|
|
'{workspace}/generated/data_sections_init_blobs.S')
|
|
product = @('@MKW_RETRO_REGISTRATION_SOURCES')
|
|
mod = @('@MKW_RETRO_PORTABLE_SENSITIVE_SHARDS', '@MKW_RETRO_MOD_SHARDS', '@MKW_RETRO_EXTRA_SOURCES')
|
|
translated = @('@MKW_BASE_COMMON_SHARDS')
|
|
}
|
|
}
|
|
}
|
|
|
|
function ConvertTo-ForwardPath([string]$Path) {
|
|
return [IO.Path]::GetFullPath($Path).Replace('\', '/').TrimEnd('/')
|
|
}
|
|
|
|
function ConvertFrom-NinjaPath([string]$Text) {
|
|
return $Text.Replace('$:', ':').Replace('$ ', ' ').Replace('$$', '$')
|
|
}
|
|
|
|
# Splits a CMake compile command. CMake quotes only arguments that need it and escapes inner
|
|
# quotes as \" (for example -DIMGUI_USER_CONFIG=\"aurora/imgui_config.h\").
|
|
function Split-CommandLine([string]$Command) {
|
|
$arguments = New-Object System.Collections.Generic.List[string]
|
|
$current = New-Object System.Text.StringBuilder
|
|
$inQuotes = $false
|
|
$pending = $false
|
|
for ($i = 0; $i -lt $Command.Length; $i++) {
|
|
$c = $Command[$i]
|
|
if ($c -eq '\' -and $i + 1 -lt $Command.Length -and $Command[$i + 1] -eq '"') {
|
|
[void]$current.Append('"'); $i++; $pending = $true; continue
|
|
}
|
|
if ($c -eq '"') { $inQuotes = -not $inQuotes; $pending = $true; continue }
|
|
if (-not $inQuotes -and [char]::IsWhiteSpace($c)) {
|
|
if ($pending) { $arguments.Add($current.ToString()); [void]$current.Clear(); $pending = $false }
|
|
continue
|
|
}
|
|
[void]$current.Append($c); $pending = $true
|
|
}
|
|
if ($pending) { $arguments.Add($current.ToString()) }
|
|
return ,$arguments.ToArray()
|
|
}
|
|
|
|
# One argument for a response file or a Windows command line (CommandLineToArgvW rules, which
|
|
# clang's GNU response-file tokenizer reads the same way for these arguments).
|
|
function ConvertTo-QuotedArgument([string]$Argument) {
|
|
if ($Argument -notmatch '[\s"]') { return $Argument }
|
|
return '"' + $Argument.Replace('"', '\"') + '"'
|
|
}
|
|
|
|
function Get-Sha256Hex([string]$Path) {
|
|
$sha = [Security.Cryptography.SHA256]::Create()
|
|
try {
|
|
$stream = [IO.File]::OpenRead($Path)
|
|
try { $bytes = $sha.ComputeHash($stream) } finally { $stream.Dispose() }
|
|
} finally { $sha.Dispose() }
|
|
return (($bytes | ForEach-Object { $_.ToString('x2') }) -join '')
|
|
}
|
|
|
|
function Get-StringSha256Hex([string]$Text) {
|
|
$sha = [Security.Cryptography.SHA256]::Create()
|
|
try { $bytes = $sha.ComputeHash([Text.Encoding]::UTF8.GetBytes($Text)) } finally { $sha.Dispose() }
|
|
return (($bytes | ForEach-Object { $_.ToString('x2') }) -join '')
|
|
}
|
|
|
|
# Identity of a runtime/include tree. Translated code compiles against these headers, so a game is
|
|
# only built from a translation whose runtime headers are the kit's own.
|
|
function Get-RuntimeIncludeFingerprint([string]$Directory) {
|
|
$lines = Get-RelativeFiles $Directory | Sort-Object FullName | ForEach-Object {
|
|
$_.Relative + ' ' + (Get-Sha256Hex $_.FullName)
|
|
}
|
|
return Get-StringSha256Hex ($lines -join "`n")
|
|
}
|
|
|
|
# The files below a directory with their paths relative to it. .NET enumeration keeps the root
|
|
# exactly as given; Resolve-Path and Get-ChildItem can disagree about an 8.3 short name (TEMP),
|
|
# which would shift every relative path.
|
|
function Get-RelativeFiles([string]$Directory) {
|
|
$root = [IO.Path]::GetFullPath($Directory).TrimEnd('\', '/')
|
|
foreach ($path in [IO.Directory]::EnumerateFiles($root, '*', [IO.SearchOption]::AllDirectories)) {
|
|
[pscustomobject]@{ FullName = $path; Relative = $path.Substring($root.Length + 1).Replace('\', '/') }
|
|
}
|
|
}
|
|
|
|
# compile_commands.json as {file, command} objects. Windows PowerShell's ConvertFrom-Json refuses
|
|
# documents over 2 MB, so 5.1 uses the serializer underneath it with the limit lifted.
|
|
function Read-CompileCommands([string]$Path) {
|
|
$text = [IO.File]::ReadAllText($Path)
|
|
if ($PSVersionTable.PSVersion.Major -ge 6) {
|
|
return @($text | ConvertFrom-Json | ForEach-Object { [pscustomobject]@{ file = $_.file; command = $_.command } })
|
|
}
|
|
Add-Type -AssemblyName System.Web.Extensions
|
|
$serializer = New-Object System.Web.Script.Serialization.JavaScriptSerializer
|
|
$serializer.MaxJsonLength = [int]::MaxValue
|
|
return @($serializer.DeserializeObject($text) | ForEach-Object { [pscustomobject]@{ file = $_['file']; command = $_['command'] } })
|
|
}
|
|
|
|
# Compile flags of one recorded command, reduced to what a generated source needs anywhere.
|
|
function ConvertTo-KitCompileFlags {
|
|
param([string[]]$Arguments, [string]$RuntimeInclude, [string]$Workspace)
|
|
$flags = New-Object System.Collections.Generic.List[string]
|
|
for ($i = 1; $i -lt $Arguments.Length; $i++) {
|
|
$a = $Arguments[$i]
|
|
switch -Regex -CaseSensitive ($a) {
|
|
'^(-o|-c|-MT|-MF)$' { $i++; continue }
|
|
'^(-MD|-MMD|-g|-Winvalid-pch)$' { continue }
|
|
'^-isystem$' { $i++; continue }
|
|
'^--sysroot=' { $flags.Add('--sysroot={sysroot}'); continue }
|
|
'^-Xclang$' {
|
|
if ($i + 3 -lt $Arguments.Length -and $Arguments[$i + 1] -eq '-include-pch') { $i += 3; continue }
|
|
if ($i + 3 -lt $Arguments.Length -and $Arguments[$i + 1] -eq '-include') {
|
|
# CMake's cmake_pch.hxx only includes the precompiled header; builders parse it
|
|
# directly (a PCH is only valid for the compiler that wrote it).
|
|
$i += 3; $flags.Add('-include'); $flags.Add('mkw_pch.h'); continue
|
|
}
|
|
$flags.Add($a); continue
|
|
}
|
|
'^-I' {
|
|
$path = ConvertTo-ForwardPath $a.Substring(2)
|
|
if ($path -eq $RuntimeInclude) { $flags.Add('-I{kit}/include') }
|
|
elseif ($path -eq $Workspace) { $flags.Add('-I{workspace}') }
|
|
continue
|
|
}
|
|
default { $flags.Add($a) }
|
|
}
|
|
}
|
|
return ,$flags.ToArray()
|
|
}
|
|
|
|
# The arguments of a `clang -###` command line: double-quoted, with backslash escapes.
|
|
function Split-DriverCommand([string]$Line) {
|
|
$arguments = New-Object System.Collections.Generic.List[string]
|
|
$current = New-Object System.Text.StringBuilder
|
|
$inQuotes = $false
|
|
for ($i = 0; $i -lt $Line.Length; $i++) {
|
|
$c = $Line[$i]
|
|
if ($inQuotes) {
|
|
if ($c -eq '\' -and $i + 1 -lt $Line.Length) { [void]$current.Append($Line[++$i]) }
|
|
elseif ($c -eq '"') { $arguments.Add($current.ToString()); [void]$current.Clear(); $inQuotes = $false }
|
|
else { [void]$current.Append($c) }
|
|
} elseif ($c -eq '"') { $inQuotes = $true }
|
|
}
|
|
return , $arguments.ToArray()
|
|
}
|
|
|
|
# The kit's link as a raw ld.lld command, for the headset. Android lets the app start its tools
|
|
# only through the system linker, so clang there cannot start lld itself and the builder runs lld
|
|
# directly. The NDK's own driver expands the link here, with the kit and marker objects standing in
|
|
# as real files. Placeholders: {kit}, {ndk} (the NDK's prebuilt toolchain directory, which holds
|
|
# sysroot/ and lib/clang/), {output}, and {game:runtime}, {game:product}, {game:translated}, each
|
|
# replaced by its object files (the translated ones already sit inside --start-lib/--end-lib).
|
|
function Get-KitLldArguments {
|
|
param([string]$ClangCxx, [string]$KitDir, [string[]]$Flags, [string[]]$Inputs, [string[]]$Slots)
|
|
$kit = ConvertTo-ForwardPath $KitDir
|
|
$ndk = ConvertTo-ForwardPath (Join-Path (Split-Path -Parent $ClangCxx) '..')
|
|
# Forward slashes throughout: clang reads response files with GNU quoting, where '\' escapes.
|
|
$probe = ConvertTo-ForwardPath (Join-Path ([IO.Path]::GetTempPath()) ('mkw-kit-link-' + [Guid]::NewGuid().ToString('N')))
|
|
New-Item -ItemType Directory $probe | Out-Null
|
|
try {
|
|
$markers = [ordered]@{}
|
|
foreach ($slot in $Slots) {
|
|
$markers[$slot] = ConvertTo-ForwardPath (Join-Path $probe "game_$slot.o")
|
|
[IO.File]::WriteAllBytes($markers[$slot], [byte[]]@())
|
|
}
|
|
$real = { param([string]$s) $s.Replace('{kit}', $kit).Replace('{sysroot}', "$ndk/sysroot") }
|
|
$arguments = New-Object System.Collections.Generic.List[string]
|
|
foreach ($flag in $Flags) { $arguments.Add((& $real $flag)) }
|
|
$arguments.Add('-o'); $arguments.Add("$probe/libmain.so")
|
|
foreach ($linkInput in $Inputs) {
|
|
$slot = [regex]::Match($linkInput, '^\{game:(\w+)\}$').Groups[1].Value
|
|
if (-not $slot) { $arguments.Add((& $real $linkInput)); continue }
|
|
# Only the base archive's slot keeps archive semantics; the rest are plain objects.
|
|
if ($slot -eq 'translated') { $arguments.Add('-Wl,--start-lib') }
|
|
$arguments.Add($markers[$slot])
|
|
if ($slot -eq 'translated') { $arguments.Add('-Wl,--end-lib') }
|
|
}
|
|
$rsp = Join-Path $probe 'link.rsp'
|
|
[IO.File]::WriteAllText($rsp, (($arguments | ForEach-Object { ConvertTo-QuotedArgument $_ }) -join "`n"), (New-Object Text.UTF8Encoding $false))
|
|
|
|
# -### prints the command on stderr; Windows PowerShell turns redirected native stderr into errors.
|
|
$start = New-Object Diagnostics.ProcessStartInfo $ClangCxx, "-### `"@$rsp`""
|
|
$start.UseShellExecute = $false
|
|
$start.RedirectStandardError = $true
|
|
$start.RedirectStandardOutput = $true
|
|
$process = [Diagnostics.Process]::Start($start)
|
|
$stdout = $process.StandardOutput.ReadToEndAsync()
|
|
$stderr = $process.StandardError.ReadToEnd()
|
|
$process.WaitForExit()
|
|
[void]$stdout.Result
|
|
if ($process.ExitCode -ne 0) { throw "clang++ -### failed for the kit link:`n$stderr" }
|
|
$line = @($stderr -split "`r?`n" | Where-Object { $_ -match '^\s*"[^"]*ld(\.lld)?(\.exe)?"' }) | Select-Object -Last 1
|
|
if (-not $line) { throw "clang++ -### printed no linker command:`n$stderr" }
|
|
|
|
$lld = New-Object System.Collections.Generic.List[string]
|
|
$driverArguments = Split-DriverCommand $line
|
|
for ($i = 1; $i -lt $driverArguments.Length; $i++) {
|
|
$argument = $driverArguments[$i].Replace('\', '/')
|
|
if ($argument -eq "$probe/libmain.so") { $lld.Add('{output}'); continue }
|
|
$slot = @($markers.Keys | Where-Object { $markers[$_] -eq $argument })
|
|
if ($slot.Count -eq 1) { $lld.Add("{game:$($slot[0])}"); continue }
|
|
$argument = [regex]::Replace($argument, [regex]::Escape($kit), '{kit}', 'IgnoreCase')
|
|
$argument = [regex]::Replace($argument, [regex]::Escape($ndk), '{ndk}', 'IgnoreCase')
|
|
if ($argument -match '[A-Za-z]:/') { throw "The kit link names a path outside the kit and the NDK: $argument" }
|
|
$lld.Add($argument)
|
|
}
|
|
foreach ($required in @('{output}') + @($Slots | ForEach-Object { "{game:$_}" })) {
|
|
if (-not $lld.Contains($required)) { throw "The expanded kit link lacks $required" }
|
|
}
|
|
return , $lld.ToArray()
|
|
} finally {
|
|
Remove-Item -Recurse -Force $probe
|
|
}
|
|
}
|
|
|
|
function Export-QuestGameKit {
|
|
[CmdletBinding()]
|
|
param(
|
|
[Parameter(Mandatory)] [string]$CMakeBinaryDir,
|
|
[Parameter(Mandatory)] [string]$OutputDir,
|
|
[Parameter(Mandatory)] [string]$RepoRoot,
|
|
[Parameter(Mandatory)] [string]$LlvmStrip,
|
|
[Parameter(Mandatory)] [string]$AndroidCpu
|
|
)
|
|
$ErrorActionPreference = 'Stop'
|
|
$binary = ConvertTo-ForwardPath $CMakeBinaryDir
|
|
$cache = [IO.File]::ReadAllText("$binary/CMakeCache.txt")
|
|
$configuredCpu = [regex]::Match($cache, '(?m)^MKW_ANDROID_CPU(?::[^=\r\n]*)?=([^\r\n]+)\r?$').Groups[1].Value.Trim()
|
|
if ($configuredCpu -ne $AndroidCpu) {
|
|
throw "CMake tree $binary targets Android CPU '$configuredCpu', expected '$AndroidCpu'"
|
|
}
|
|
$runtimeInclude = ConvertTo-ForwardPath (Join-Path $RepoRoot 'runtime/include')
|
|
$ninja = [IO.File]::ReadAllText("$binary/build.ninja")
|
|
$commands = Read-CompileCommands "$binary/compile_commands.json"
|
|
$rules = if (Test-Path "$binary/CMakeFiles/rules.ninja") { [IO.File]::ReadAllText("$binary/CMakeFiles/rules.ninja") } else { '' }
|
|
|
|
function Find-Command([string]$Pattern) {
|
|
$entry = @($commands | Where-Object { $_.file.Replace('\', '/') -match $Pattern })
|
|
if ($entry.Count -eq 0) { throw "compile_commands.json has no source matching $Pattern" }
|
|
return $entry[0]
|
|
}
|
|
$translatedEntry = Find-Command '/build_shards/base_common/[^/]+\.cpp$'
|
|
$workspace = ConvertTo-ForwardPath ($translatedEntry.file.Replace('\', '/') -replace '/generated/build_shards/.*$', '')
|
|
$flagsFor = {
|
|
param($Entry)
|
|
ConvertTo-KitCompileFlags -Arguments (Split-CommandLine $Entry.command) -RuntimeInclude $runtimeInclude -Workspace $workspace
|
|
}
|
|
|
|
if (Test-Path $OutputDir) { Remove-Item -Recurse -Force $OutputDir }
|
|
New-Item -ItemType Directory -Force (Join-Path $OutputDir 'objects'), (Join-Path $OutputDir 'libs') | Out-Null
|
|
Copy-Item -Recurse (Join-Path $RepoRoot 'runtime/include') (Join-Path $OutputDir 'include')
|
|
|
|
# One copy of every object and archive, however many products link it: the two probes differ
|
|
# only in their own product object.
|
|
$copied = @{}
|
|
$script:kitIndex = 0
|
|
$copy = {
|
|
param([string]$Source, [string]$Directory)
|
|
$full = ConvertTo-ForwardPath $(if ([IO.Path]::IsPathRooted($Source)) { $Source } else { "$binary/$Source" })
|
|
if ($copied.ContainsKey($full)) { return $copied[$full] }
|
|
$script:kitIndex++
|
|
$name = '{0:D3}_{1}' -f $script:kitIndex, [IO.Path]::GetFileName($full)
|
|
$destination = Join-Path (Join-Path $OutputDir $Directory) $name
|
|
& $LlvmStrip --strip-debug -o $destination $full
|
|
if ($LASTEXITCODE -ne 0) { throw "llvm-strip failed on $full" }
|
|
$copied[$full] = "{kit}/$Directory/$name"
|
|
return $copied[$full]
|
|
}
|
|
|
|
# One recipe per product this CMake tree built a probe for. The base one must be there; Retro
|
|
# Rewind's exists only once translate-mod and emit-build-shards have run.
|
|
$products = [ordered]@{}
|
|
foreach ($product in 'base', 'retro_rewind') {
|
|
$kitProfile = $script:KitProfiles[$product]
|
|
$edge = [regex]::Match($ninja, "(?m)^build (\S*$([regex]::Escape($kitProfile.Probe))\.so): (\S+) ([^\r\n]*)\r?\n((?: [^\r\n]*\r?\n)+)")
|
|
if (-not $edge.Success) {
|
|
if ($product -eq 'base') { throw "No $($kitProfile.Probe) link edge in $binary/build.ninja" }
|
|
Write-Host "No $($kitProfile.Probe) in this build; the kit carries the base game only."
|
|
continue
|
|
}
|
|
$explicit = ($edge.Groups[3].Value.Replace('$ ', '<ninja-space>') -split ' \|')[0]
|
|
$objects = @($explicit -split ' ' | Where-Object { $_ } | ForEach-Object { ConvertFrom-NinjaPath $_.Replace('<ninja-space>', '$ ') })
|
|
$vars = @{}
|
|
foreach ($line in ($edge.Groups[4].Value -split "\r?\n")) {
|
|
if ($line -match '^ (\w+) = (.*)$') { $vars[$Matches[1]] = $Matches[2] }
|
|
}
|
|
$rule = [regex]::Match($ninja, "(?ms)^rule $([regex]::Escape($edge.Groups[2].Value))\r?\n.*?command = ([^\r\n]*)")
|
|
if (-not $rule.Success) {
|
|
$rule = [regex]::Match($rules, "(?ms)^rule $([regex]::Escape($edge.Groups[2].Value))\r?\n.*?command = ([^\r\n]*)")
|
|
}
|
|
$target = [regex]::Match($rule.Groups[1].Value, '--target=(\S+)').Groups[1].Value
|
|
if (-not $target) { throw "Cannot read the link target triple from rule $($edge.Groups[2].Value)" }
|
|
|
|
# Link inputs in the probe's order, with the game's slots marked where the product has them.
|
|
$inputs = New-Object System.Collections.Generic.List[string]
|
|
$lastRuntime = -1
|
|
for ($i = 0; $i -lt $objects.Count; $i++) {
|
|
if ($objects[$i] -match '/mkw_runtime_common\.dir/') { $lastRuntime = $i }
|
|
}
|
|
for ($i = 0; $i -lt $objects.Count; $i++) {
|
|
$inputs.Add((& $copy $objects[$i] 'objects'))
|
|
if ($objects[$i] -match $kitProfile.ProductObjectPattern) { $inputs.Add('{game:product}') }
|
|
if ($i -eq $lastRuntime) {
|
|
$inputs.Add('{game:runtime}')
|
|
# Retro Rewind links the mod's own objects after the runtime's, as its CMake target does.
|
|
if ($kitProfile.Slots -contains 'mod') { $inputs.Add('{game:mod}') }
|
|
}
|
|
}
|
|
foreach ($slot in $kitProfile.Slots) {
|
|
if ($slot -ne 'translated' -and -not $inputs.Contains("{game:$slot}")) {
|
|
throw "The $product probe link line lacks the objects the {game:$slot} slot follows"
|
|
}
|
|
}
|
|
foreach ($token in ((ConvertFrom-NinjaPath $vars['LINK_LIBRARIES']) -split ' ' | Where-Object { $_ })) {
|
|
if ($token.StartsWith('-')) { $inputs.Add($token); continue }
|
|
$path = $token.Replace('\', '/')
|
|
if ($path -match '/sysroot/(.+)$') { $inputs.Add("{sysroot}/$($Matches[1])") }
|
|
else { $inputs.Add((& $copy $token 'libs')) }
|
|
if ($path -match '/libmkw_platform\.a$') { $inputs.Add('{game:translated}') }
|
|
}
|
|
if (-not $inputs.Contains('{game:translated}')) { throw "The $product probe link line lacks libmkw_platform.a" }
|
|
|
|
$linkFlags = New-Object System.Collections.Generic.List[string]
|
|
$linkFlags.Add("--target=$target"); $linkFlags.Add('--sysroot={sysroot}'); $linkFlags.Add('-fPIC')
|
|
foreach ($name in 'LANGUAGE_COMPILE_FLAGS', 'ARCH_FLAGS', 'LINK_FLAGS') {
|
|
if (-not $vars.ContainsKey($name)) { continue }
|
|
$tokens = Split-CommandLine (ConvertFrom-NinjaPath $vars[$name])
|
|
for ($i = 0; $i -lt $tokens.Length; $i++) {
|
|
if ($tokens[$i] -eq '-g' -or $tokens[$i] -eq '-Wl,--unresolved-symbols=ignore-all') { continue }
|
|
if ($tokens[$i] -eq '-Xlinker' -and $i + 1 -lt $tokens.Length -and $tokens[$i + 1].StartsWith('--dependency-file')) { $i++; continue }
|
|
$linkFlags.Add($tokens[$i])
|
|
}
|
|
}
|
|
$linkFlags.Add('-Wl,-soname,libmain.so')
|
|
|
|
$products[$product] = [ordered]@{
|
|
output = 'libmain.so'
|
|
target = $target
|
|
compile = [ordered]@{
|
|
translated = & $flagsFor $translatedEntry
|
|
product = & $flagsFor (Find-Command $kitProfile.RegistrationPattern)
|
|
runtime = & $flagsFor (Find-Command '/generated/data_sections_init\.cpp$')
|
|
asm = & $flagsFor (Find-Command 'data_sections_init_blobs[^/]*\.S$')
|
|
}
|
|
sources = $kitProfile.Sources
|
|
link = [ordered]@{
|
|
flags = $linkFlags.ToArray()
|
|
inputs = $inputs.ToArray()
|
|
lld = Get-KitLldArguments -ClangCxx (Join-Path (Split-Path -Parent $LlvmStrip) 'clang++.exe') -KitDir $OutputDir `
|
|
-Flags $linkFlags.ToArray() -Inputs $inputs.ToArray() -Slots $kitProfile.Slots
|
|
}
|
|
}
|
|
}
|
|
|
|
# What the headset's translator needs besides the disc: the game manifest and symbol map, and
|
|
# the runtime sources it indexes for native registrations, which must be the ones compiled into
|
|
# this kit.
|
|
$translation = Join-Path $OutputDir 'translation'
|
|
New-Item -ItemType Directory -Force (Join-Path $translation 'projects/mkwii'), (Join-Path $translation 'runtime') | Out-Null
|
|
Copy-Item (Join-Path $RepoRoot 'projects/mkwii/recomp.yml'), (Join-Path $RepoRoot 'projects/mkwii/MAP.txt') (Join-Path $translation 'projects/mkwii')
|
|
Copy-Item -Recurse (Join-Path $RepoRoot 'runtime/src') (Join-Path $translation 'runtime/src')
|
|
|
|
$recipe = [ordered]@{
|
|
schema = $script:KitSchema
|
|
androidCpu = $AndroidCpu
|
|
runtimeIncludeFingerprint = Get-RuntimeIncludeFingerprint (Join-Path $OutputDir 'include')
|
|
products = $products
|
|
}
|
|
$recipeJson = $recipe | ConvertTo-Json -Depth 8 -Compress
|
|
$files = Get-RelativeFiles $OutputDir | Sort-Object FullName | ForEach-Object {
|
|
"/$($_.Relative) $(Get-Sha256Hex $_.FullName)"
|
|
}
|
|
$recipe.fingerprint = Get-StringSha256Hex ($recipeJson + "`n" + ($files -join "`n"))
|
|
[IO.File]::WriteAllText((Join-Path $OutputDir 'kit.json'), ($recipe | ConvertTo-Json -Depth 8), (New-Object Text.UTF8Encoding $false))
|
|
return [pscustomobject]@{ Fingerprint = $recipe.fingerprint; Products = @($products.Keys) }
|
|
}
|
|
|
|
# The generated source lists emit-build-shards wrote into shards.cmake.
|
|
function Read-ShardList {
|
|
param([string]$ShardsCmake, [string]$Name)
|
|
$text = [IO.File]::ReadAllText($ShardsCmake)
|
|
$match = [regex]::Match($text, "(?s)set\($Name\s*(.*?)\)")
|
|
if (-not $match.Success) { return @() }
|
|
return @([regex]::Matches($match.Groups[1].Value, '"([^"]+)"') | ForEach-Object { $_.Groups[1].Value.Replace('\', '/') })
|
|
}
|
|
|
|
function Invoke-QuestGameBuild {
|
|
[CmdletBinding()]
|
|
param(
|
|
[Parameter(Mandatory)] [string]$KitDir,
|
|
[Parameter(Mandatory)] [string]$GeneratedDir,
|
|
[Parameter(Mandatory)] [string]$BuildDir,
|
|
[Parameter(Mandatory)] [string]$ClangCxx,
|
|
[Parameter(Mandatory)] [string]$ClangC,
|
|
[Parameter(Mandatory)] [string]$Sysroot,
|
|
[Parameter(Mandatory)] [string]$Ninja,
|
|
[Parameter(Mandatory)] [int]$TranslatedJobs,
|
|
[ValidateSet('base', 'retro_rewind')] [string]$Product = 'base'
|
|
)
|
|
$ErrorActionPreference = 'Stop'
|
|
$kit = ConvertTo-ForwardPath $KitDir
|
|
$generated = ConvertTo-ForwardPath $GeneratedDir
|
|
$workspace = ConvertTo-ForwardPath (Split-Path -Parent $generated)
|
|
$recipe = [IO.File]::ReadAllText("$kit/kit.json") | ConvertFrom-Json
|
|
if ($recipe.schema -ne $script:KitSchema) { throw "Unsupported game kit schema $($recipe.schema)" }
|
|
if ([string]::IsNullOrWhiteSpace($recipe.androidCpu)) { throw 'The game kit does not name its Android CPU target' }
|
|
if (-not $recipe.products.PSObject.Properties.Name.Contains($Product)) {
|
|
throw "This Quest app's game kit cannot build $Product (it has: $($recipe.products.PSObject.Properties.Name -join ', '))"
|
|
}
|
|
$productRecipe = $recipe.products.$Product
|
|
foreach ($kind in 'translated', 'product', 'runtime', 'asm') {
|
|
if (@($productRecipe.compile.$kind) -notcontains "-mcpu=$($recipe.androidCpu)") {
|
|
throw "The game kit says CPU '$($recipe.androidCpu)' but its $kind compile flags do not match"
|
|
}
|
|
}
|
|
# The translation must come from the same release as the kit: its code is compiled against the
|
|
# kit's runtime headers and linked with the kit's runtime objects.
|
|
$workspaceInclude = Join-Path $workspace 'runtime/include'
|
|
if (Test-Path $workspaceInclude) {
|
|
if ((Get-RuntimeIncludeFingerprint $workspaceInclude) -ne $recipe.runtimeIncludeFingerprint) {
|
|
throw ('The Quest app and the translation on this PC come from different WiiCompiled releases ' +
|
|
'(their runtime headers differ). Update both to the same release, then build again.')
|
|
}
|
|
}
|
|
New-Item -ItemType Directory -Force $BuildDir | Out-Null
|
|
$build = ConvertTo-ForwardPath $BuildDir
|
|
# Ninja sees the response-file path in each command, not changes to that file's contents. A
|
|
# different kit can therefore otherwise reuse objects compiled with another flavour's -mcpu.
|
|
# Keep an explicit identity next to the build and discard every reusable native output when it
|
|
# changes. WiiCompiled Setup deliberately reuses one BuildDir across APK selections.
|
|
$identity = "$($recipe.fingerprint) $Product"
|
|
$identityFile = "$build/kit-identity.txt"
|
|
$previousIdentity = if (Test-Path $identityFile) { [IO.File]::ReadAllText($identityFile).Trim() } else { '' }
|
|
if ($previousIdentity -ne $identity) {
|
|
foreach ($stale in 'obj', 'libmain.so', '.ninja_deps', '.ninja_log') {
|
|
$path = "$build/$stale"
|
|
if (Test-Path $path) { Remove-Item -Recurse -Force $path }
|
|
}
|
|
}
|
|
[IO.File]::WriteAllText($identityFile, $identity, (New-Object Text.UTF8Encoding $false))
|
|
$expand = { param([string]$s) $s.Replace('{kit}', $kit).Replace('{sysroot}', (ConvertTo-ForwardPath $Sysroot)).Replace('{workspace}', $workspace) }
|
|
|
|
foreach ($kind in 'translated', 'product', 'runtime', 'asm') {
|
|
$lines = @($productRecipe.compile.$kind | ForEach-Object { ConvertTo-QuotedArgument (& $expand $_) })
|
|
[IO.File]::WriteAllText("$build/$kind.rsp", ($lines -join "`n"), (New-Object Text.UTF8Encoding $false))
|
|
}
|
|
$linkLines = @($productRecipe.link.flags | ForEach-Object { ConvertTo-QuotedArgument (& $expand $_) })
|
|
[IO.File]::WriteAllText("$build/link.rsp", ($linkLines -join "`n"), (New-Object Text.UTF8Encoding $false))
|
|
|
|
# The Windows installer generates blob assembly for PE/COFF; every one of them is rewritten for
|
|
# ELF exactly as runtime/cmake/PublicProducts.cmake does, into the build directory.
|
|
$toElf = {
|
|
param([string]$Source)
|
|
$text = [IO.File]::ReadAllText($Source)
|
|
$elf = $text.Replace('.section .rdata,"dr"', '.section .rodata,"a",@progbits')
|
|
if ($elf -ne $text) { $elf += "`n.section .note.GNU-stack,`"`",@progbits`n" }
|
|
$rewritten = "$build/$([IO.Path]::GetFileNameWithoutExtension($Source))_android.S"
|
|
[IO.File]::WriteAllText($rewritten, $elf, (New-Object Text.UTF8Encoding $false))
|
|
return $rewritten
|
|
}
|
|
|
|
# Each slot's sources, as the recipe names them: a build_shards list ("@NAME") or one generated
|
|
# file.
|
|
$shards = "$generated/build_shards/shards.cmake"
|
|
$sources = [ordered]@{}
|
|
foreach ($slot in $productRecipe.sources.PSObject.Properties.Name) {
|
|
$slotSources = New-Object System.Collections.Generic.List[string]
|
|
foreach ($entry in $productRecipe.sources.$slot) {
|
|
if ($entry.StartsWith('@')) {
|
|
Read-ShardList $shards $entry.Substring(1) | ForEach-Object { $slotSources.Add($_) }
|
|
} else {
|
|
$slotSources.Add((& $expand $entry))
|
|
}
|
|
}
|
|
$sources[$slot] = @($slotSources | ForEach-Object { if ($_.EndsWith('.S')) { & $toElf $_ } else { $_ } })
|
|
}
|
|
if ($sources.translated.Count -eq 0) { throw "No translated shards in $shards" }
|
|
# Online play needs the Retro-WFC payload translated into the mod (translate-mod
|
|
# --retro-wfc-payload). Without it the mod downloads the payload at run time and jumps into
|
|
# code that was never translated: the game crashes on entering Retro Rewind WFC.
|
|
if ($Product -eq 'retro_rewind') {
|
|
$dataPatches = @($sources.Values | ForEach-Object { $_ } |
|
|
Where-Object { [IO.Path]::GetFileName($_) -eq 'mod_data_patches.cpp' })
|
|
if ($dataPatches.Count -ne 1 -or
|
|
-not (Select-String -LiteralPath $dataPatches[0] -Pattern 'kRetroWfcInitializerAddress' -SimpleMatch -Quiet)) {
|
|
throw ('This Retro Rewind translation has no Retro-WFC payload, so online play would crash. ' +
|
|
'Translate the mod again with its payload (translate-mod --retro-wfc-payload, or repair ' +
|
|
'Retro Rewind in WiiCompiled with the payload download on), then build again.')
|
|
}
|
|
}
|
|
foreach ($slot in $sources.Keys) {
|
|
if ($sources[$slot].Count -eq 0) { throw "The $slot sources of a $Product game are missing from $shards" }
|
|
}
|
|
|
|
$ninjaText = New-Object System.Text.StringBuilder
|
|
$escape = { param([string]$p) $p.Replace('$', '$$').Replace(':', '$:').Replace(' ', '$ ') }
|
|
[void]$ninjaText.AppendLine('ninja_required_version = 1.10')
|
|
[void]$ninjaText.AppendLine("pool translated`n depth = $TranslatedJobs")
|
|
# Depfiles, so a changed runtime header recompiles the shards that include it instead of
|
|
# leaving objects built against the previous kit.
|
|
[void]$ninjaText.AppendLine("rule cxx`n command = $(ConvertTo-QuotedArgument $ClangCxx) @`$flags -MD -MF `$out.d -c `$in -o `$out`n depfile = `$out.d`n deps = gcc`n description = Compiling `$in")
|
|
[void]$ninjaText.AppendLine("rule asm`n command = $(ConvertTo-QuotedArgument $ClangC) @`$flags -c `$in -o `$out`n description = Assembling `$in")
|
|
[void]$ninjaText.AppendLine("rule link`n command = $(ConvertTo-QuotedArgument $ClangCxx) @`$flags -o `$out @`$out.rsp`n rspfile = `$out.rsp`n rspfile_content = `$inputs`n description = Linking `$out")
|
|
$objectsOf = @{}
|
|
$seen = @{}
|
|
foreach ($slot in $sources.Keys) {
|
|
$objectsOf[$slot] = @()
|
|
foreach ($source in $sources[$slot]) {
|
|
$stem = [IO.Path]::GetFileNameWithoutExtension($source)
|
|
$object = "obj/$stem.o"
|
|
if ($seen.ContainsKey($object)) { throw "Two generated sources share the object name $object" }
|
|
$seen[$object] = $true
|
|
# Assembly is assembled; a mod shard compiles with the same flags as a translated one.
|
|
$assembly = $source.EndsWith('.S')
|
|
$rule = if ($assembly) { 'asm' } else { 'cxx' }
|
|
$flags = if ($assembly) { 'asm.rsp' } elseif ($slot -eq 'mod') { 'translated.rsp' } else { "$slot.rsp" }
|
|
[void]$ninjaText.AppendLine("build $(& $escape $object): $rule $(& $escape $source)`n flags = $(& $escape "$build/$flags")")
|
|
if ($slot -eq 'translated' -or $slot -eq 'mod') { [void]$ninjaText.AppendLine(' pool = translated') }
|
|
$objectsOf[$slot] += "$build/$object"
|
|
}
|
|
}
|
|
$linkInputs = New-Object System.Collections.Generic.List[string]
|
|
foreach ($linkInput in $productRecipe.link.inputs) {
|
|
$slot = [regex]::Match($linkInput, '^\{game:(\w+)\}$').Groups[1].Value
|
|
if (-not $slot) { $linkInputs.Add((& $expand $linkInput)); continue }
|
|
if (-not $objectsOf.ContainsKey($slot)) { throw "The kit recipe links a {game:$slot} slot it names no sources for" }
|
|
# The base shards keep the archive semantics libmkw_base_shared.a has in a CMake build;
|
|
# every other slot is linked as plain objects, as the product's own CMake target does.
|
|
if ($slot -eq 'translated') { $linkInputs.Add('-Wl,--start-lib') }
|
|
$objectsOf[$slot] | ForEach-Object { $linkInputs.Add($_) }
|
|
if ($slot -eq 'translated') { $linkInputs.Add('-Wl,--end-lib') }
|
|
}
|
|
$allObjects = @($sources.Keys | ForEach-Object { $objectsOf[$_] } | ForEach-Object { & $escape $_.Substring($build.Length + 1) })
|
|
$rspInputs = ($linkInputs | ForEach-Object { ConvertTo-QuotedArgument $_ }) -join ' '
|
|
# The kit's objects and archives keep their names from one kit export to the next, so they are
|
|
# implicit inputs of the link: a game built against an earlier kit is relinked, not reused.
|
|
$kitInputs = @($linkInputs | Where-Object { $_.StartsWith($kit) } | ForEach-Object { & $escape $_ })
|
|
[void]$ninjaText.AppendLine("build libmain.so: link $($allObjects -join ' ') | $($kitInputs -join ' ')`n flags = $(& $escape "$build/link.rsp")`n inputs = $($rspInputs.Replace('$', '$$'))")
|
|
[IO.File]::WriteAllText("$build/build.ninja", $ninjaText.ToString(), (New-Object Text.UTF8Encoding $false))
|
|
|
|
# Ninja's progress goes to the console, not into this function's return value; its [n/N]
|
|
# lines are what WiiCompiled Setup turns into build progress.
|
|
Write-Host 'MKWCBUILD:STEP:quest-compile Compiling the game for Quest'
|
|
& $Ninja -C $build | Out-Host
|
|
if ($LASTEXITCODE -ne 0) { throw "Game build failed (ninja exit $LASTEXITCODE)" }
|
|
return "$build/libmain.so"
|
|
}
|
|
|
|
# A .wcgame: the built library and what it was built from, for the headset to import. It can also
|
|
# carry, written without compression, the extracted disc (-DataDir, as DATA/...) and the Retro
|
|
# Rewind pack (-ModDir, as MOD/...), so a player who builds on a PC copies one file to the headset
|
|
# and needs nothing else there.
|
|
function New-QuestGamePackage {
|
|
[CmdletBinding()]
|
|
param(
|
|
[Parameter(Mandatory)] [string]$Library,
|
|
[string]$DataDir = '',
|
|
[string]$ModDir = '',
|
|
[Parameter(Mandatory)] [string]$KitDir,
|
|
[Parameter(Mandatory)] [string]$GameId,
|
|
[Parameter(Mandatory)] [string]$DolSha256,
|
|
[Parameter(Mandatory)] [string]$RelSha256,
|
|
[Parameter(Mandatory)] [string]$BuiltBy,
|
|
[Parameter(Mandatory)] [string]$OutputPath,
|
|
[ValidateSet('base', 'retro_rewind')] [string]$Product = 'base'
|
|
)
|
|
$ErrorActionPreference = 'Stop'
|
|
$recipe = [IO.File]::ReadAllText((Join-Path $KitDir 'kit.json')) | ConvertFrom-Json
|
|
if ($ModDir -and $Product -ne 'retro_rewind') { throw 'Only a Retro Rewind game carries the mod pack.' }
|
|
$game = [ordered]@{
|
|
schema = $script:GameSchema
|
|
profile = $Product
|
|
gameId = $GameId
|
|
dolSha256 = $DolSha256
|
|
relSha256 = $RelSha256
|
|
kitFingerprint = $recipe.fingerprint
|
|
androidCpu = $recipe.androidCpu
|
|
library = $recipe.products.$Product.output
|
|
librarySha256 = Get-Sha256Hex $Library
|
|
includesData = [bool]$DataDir
|
|
includesMod = [bool]$ModDir
|
|
builtBy = $BuiltBy
|
|
builtAt = (Get-Date).ToUniversalTime().ToString('yyyy-MM-ddTHH:mm:ssZ')
|
|
}
|
|
Add-Type -AssemblyName System.IO.Compression, System.IO.Compression.FileSystem
|
|
if (Test-Path $OutputPath) { Remove-Item -Force $OutputPath }
|
|
New-Item -ItemType Directory -Force (Split-Path -Parent ([IO.Path]::GetFullPath($OutputPath))) | Out-Null
|
|
$zip = [IO.Compression.ZipFile]::Open($OutputPath, 'Create')
|
|
try {
|
|
$entry = $zip.CreateEntry('game.json')
|
|
$writer = New-Object IO.StreamWriter($entry.Open(), (New-Object Text.UTF8Encoding $false))
|
|
try { $writer.Write(($game | ConvertTo-Json)) } finally { $writer.Dispose() }
|
|
[void][IO.Compression.ZipFileExtensions]::CreateEntryFromFile($zip, $Library, $game.library, 'Optimal')
|
|
foreach ($tree in @{ Prefix = 'DATA'; Directory = $DataDir }, @{ Prefix = 'MOD'; Directory = $ModDir }) {
|
|
if (-not $tree.Directory) { continue }
|
|
foreach ($file in Get-RelativeFiles $tree.Directory) {
|
|
[void][IO.Compression.ZipFileExtensions]::CreateEntryFromFile(
|
|
$zip, $file.FullName, "$($tree.Prefix)/$($file.Relative)", 'NoCompression')
|
|
}
|
|
}
|
|
} finally { $zip.Dispose() }
|
|
return $game
|
|
}
|
|
|
|
Export-ModuleMember -Function Export-QuestGameKit, Invoke-QuestGameBuild, New-QuestGamePackage
|