Bump Version

* When rupees are given as starting items, they still modify `gSaveContext.rupeeAccumulator`, which means that if you make a new file, start it, and reload without saving, or exit SoH before starting the new file, those rupees were lost. This adds a check for `gPlayState` being NULL, and if it is, adds those initial rupees to the rupee count directly.

* Update soh/src/code/z_parameter.c

Co-authored-by: briaguya <70942617+briaguya-ai@users.noreply.github.com>

---------

Co-authored-by: briaguya <70942617+briaguya-ai@users.noreply.github.com>

.devcontainer/Dockerfile

@@ -0,0 +1,27 @@
+FROM mcr.microsoft.com/devcontainers/cpp:ubuntu-22.04
+
+RUN apt-get update && apt-get install -y libsdl2-dev libsdl2-net-dev libpng-dev libglew-dev ninja-build
+
+# Install latest SDL2
+RUN wget https://www.libsdl.org/release/SDL2-2.26.1.tar.gz && \
+   tar -xzf SDL2-2.26.1.tar.gz && \
+    cd SDL2-2.26.1 && \
+    ./configure && \
+    make && \
+    make install && \
+    cd .. && \
+    rm -rf SDL2-2.26.1 && \
+    rm SDL2-2.26.1.tar.gz && \
+    cp -av /usr/local/lib/libSDL* /lib/x86_64-linux-gnu/
+
+# Install latest SDL2_net
+RUN wget https://www.libsdl.org/projects/SDL_net/release/SDL2_net-2.2.0.tar.gz && \
+   tar -xzf SDL2_net-2.2.0.tar.gz && \
+    cd SDL2_net-2.2.0 && \
+    ./configure && \
+    make && \
+    make install && \
+    cd .. && \
+    rm -rf SDL2_net-2.2.0 && \
+    rm SDL2_net-2.2.0.tar.gz && \
+    cp -av /usr/local/lib/libSDL* /lib/x86_64-linux-gnu/

.devcontainer/devcontainer.json

@@ -0,0 +1,29 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the
+// README at: https://github.com/devcontainers/templates/tree/main/src/cpp
+{
+	"name": "SoH",
+	"build": {
+		"dockerfile": "Dockerfile"
+	},
+
+	// Features to add to the dev container. More info: https://containers.dev/features.
+	// "features": {},
+
+	// Configure tool-specific properties.
+	"customizations": {
+		// Configure properties specific to VS Code.
+		"vscode": {
+			"settings": {},
+			"extensions": []
+		}
+	}
+
+	// Use 'forwardPorts' to make a list of ports inside the container available locally.
+	// "forwardPorts": [],
+
+	// Use 'postCreateCommand' to run commands after the container is created.
+	// "postCreateCommand": "gcc -v",
+
+	// Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
+	// "remoteUser": "root"
+}

.github/workflows/apt-deps.txt

@@ -0,0 +1 @@
+libsdl2-dev libsdl2-net-dev libpng-dev libglew-dev ninja-build 

.github/workflows/generate-builds.yml

@@ -0,0 +1,221 @@
+name: generate-builds
+on:
+  push:
+  pull_request:
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+jobs:
+  build-macos:
+    runs-on: macos-12
+    steps:
+    - uses: actions/checkout@v3
+      with:
+        submodules: true
+    - name: ccache
+      uses: hendrikmuhs/ccache-action@v1.2
+      with:
+        key: ${{ runner.os }}-ccache
+    - name: Install gtar wrapper
+      run: |
+        sudo mv /usr/local/bin/gtar /usr/local/bin/gtar.orig
+        sudo cp .github/workflows//gtar /usr/local/bin/gtar
+        sudo chmod +x /usr/local/bin/gtar
+    - name: Cache MacPorts
+      id: cache-macports
+      uses: actions/cache@v2
+      with:
+        path: /opt/local/
+        key: ${{ runner.os }}-macports-${{ hashFiles('.github/workflows/macports-deps.txt') }}
+        restore-keys: |
+          ${{ runner.os }}-macports-
+    - name: Install MacPorts (if necessary)
+      run: |
+        if [ -d /opt/local/ ]; then
+          echo "MacPorts already installed"
+        else
+          wget https://github.com/macports/macports-base/releases/download/v2.7.2/MacPorts-2.7.2-12-Monterey.pkg
+          sudo installer -pkg ./MacPorts-2.7.2-12-Monterey.pkg -target /
+        fi
+        echo "/opt/local/bin:/opt/local/sbin" >> $GITHUB_PATH
+    - name: Install dependencies
+      run: |
+        brew uninstall --ignore-dependencies libpng
+        sudo port install $(cat .github/workflows/macports-deps.txt)
+        brew install ninja
+    - name: Build SoH
+      run: |
+        export PATH="/usr/lib/ccache:/usr/local/opt/ccache/libexec:$PATH"
+        cmake --no-warn-unused-cli -H. -Bbuild-cmake -GNinja -DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_OSX_ARCHITECTURES="x86_64;arm64"
+        cmake --build build-cmake --config Release --parallel 10
+        (cd build-cmake && cpack)
+
+        mv _packages/*.dmg SoH.dmg
+        mv README.md readme.txt
+    - name: Upload build
+      uses: actions/upload-artifact@v3
+      with:
+        name: soh-mac
+        path: |
+          SoH.dmg
+          readme.txt
+  build-linux:
+    strategy:
+      fail-fast: true
+      matrix:
+        include:
+        - os: ubuntu-20.04
+          gcc: 10
+          archive-suffix: compatibility
+        - os: ubuntu-22.04
+          gcc: 12
+          archive-suffix: performance
+    runs-on: ${{ matrix.os }}
+    steps:
+    - uses: actions/checkout@v3
+      with:
+        submodules: true
+    - name: Install dependencies
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y $(cat .github/workflows/apt-deps.txt)
+    - name: ccache
+      uses: hendrikmuhs/ccache-action@v1.2
+      with:
+        key: ${{ matrix.os }}-ccache
+    - name: Install latest SDL
+      run: |
+        export PATH="/usr/lib/ccache:/usr/local/opt/ccache/libexec:$PATH"
+        wget https://www.libsdl.org/release/SDL2-2.26.1.tar.gz
+        tar -xzf SDL2-2.26.1.tar.gz
+        cd SDL2-2.26.1
+        ./configure
+        make -j 10
+        sudo make install
+        sudo cp -av /usr/local/lib/libSDL* /lib/x86_64-linux-gnu/
+    - name: Install latest SDL_net
+      run: |
+        export PATH="/usr/lib/ccache:/usr/local/opt/ccache/libexec:$PATH"
+        wget https://www.libsdl.org/projects/SDL_net/release/SDL2_net-2.2.0.tar.gz
+        tar -xzf SDL2_net-2.2.0.tar.gz
+        cd SDL2_net-2.2.0
+        ./configure
+        make -j 10
+        sudo make install
+        sudo cp -av /usr/local/lib/libSDL* /lib/x86_64-linux-gnu/
+    - name: Build SoH
+      run: |
+        export PATH="/usr/lib/ccache:/usr/local/opt/ccache/libexec:$PATH"
+        cmake --no-warn-unused-cli -H. -Bbuild-cmake -GNinja -DCMAKE_BUILD_TYPE:STRING=Release
+        cmake --build build-cmake --target OTRGui -j3
+        cmake --build build-cmake --config Release -j3
+        (cd build-cmake && cpack -G External)
+
+        mv README.md readme.txt
+        mv build-cmake/*.appimage soh.appimage
+      env:
+        CC: gcc-${{ matrix.gcc }}
+        CXX: g++-${{ matrix.gcc }}
+    - name: Upload build
+      uses: actions/upload-artifact@v3
+      with:
+        name: soh-linux-${{ matrix.archive-suffix }}
+        path: |
+          soh.appimage
+          readme.txt
+  build-switch:
+    runs-on: ubuntu-latest
+    container:
+      image: devkitpro/devkita64:latest
+    steps:
+    - name: Install dependencies
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y ninja-build
+    - uses: actions/checkout@v3
+      with:
+        submodules: true
+    - name: ccache
+      uses: hendrikmuhs/ccache-action@v1.2
+      with:
+        key: ${{ runner.os }}-switch-ccache
+    - name: Build SoH
+      run: |
+        cmake -H. -Bbuild-switch -GNinja -DCMAKE_TOOLCHAIN_FILE=/opt/devkitpro/cmake/Switch.cmake -DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_CXX_COMPILER_LAUNCHER=ccache -DCMAKE_C_COMPILER_LAUNCHER=ccache
+        cmake --build build-switch --target soh_nro -j3
+
+        mv build-switch/soh/*.nro soh.nro
+        mv README.md readme.txt
+    - name: Upload build
+      uses: actions/upload-artifact@v3
+      with:
+        name: soh-switch
+        path: |
+          soh.nro
+          readme.txt
+  build-wiiu:
+    runs-on: ubuntu-latest
+    container:
+      image: devkitpro/devkitppc:latest
+    steps:
+    - name: Install dependencies
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y ninja-build
+    - uses: actions/checkout@v3
+      with:
+        submodules: true
+    - name: ccache
+      uses: hendrikmuhs/ccache-action@v1.2
+      with:
+        key: ${{ runner.os }}-wiiu-ccache
+    - name: Build SoH
+      run: |
+        cmake -H. -Bbuild-wiiu -GNinja -DCMAKE_TOOLCHAIN_FILE=/opt/devkitpro/cmake/WiiU.cmake -DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_CXX_COMPILER_LAUNCHER=ccache -DCMAKE_C_COMPILER_LAUNCHER=ccache
+        cmake --build build-wiiu --target soh_wuhb --config Release -j3
+
+        mv build-wiiu/soh/*.rpx soh.rpx
+        mv build-wiiu/soh/*.wuhb soh.wuhb
+        mv README.md readme.txt
+      env:
+        DEVKITPRO: /opt/devkitpro
+        DEVKITPPC: /opt/devkitpro/devkitPPC
+    - name: Upload build
+      uses: actions/upload-artifact@v3
+      with:
+        name: soh-wiiu
+        path: |
+          soh.rpx
+          soh.wuhb
+          readme.txt
+  build-windows:
+    runs-on: windows-latest
+    steps:
+    - name: Install dependencies
+      run: |
+        choco install ninja
+        Remove-Item -Path "C:\ProgramData\Chocolatey\bin\ccache.exe" -Force
+    - uses: actions/checkout@v3
+      with:
+        submodules: true
+    - name: ccache
+      uses: dcvz/ccache-action@27b9f33213c0079872f064f6b6ba0233dfa16ba2
+      with:
+        key: ${{ runner.os }}-ccache
+    - uses: ilammy/msvc-dev-cmd@v1
+    - name: Setup 7-Zip
+      run: |
+        "C:\Program Files\7-Zip" >> $env:GITHUB_PATH
+    - name: Build SoH
+      run: |
+        set $env:PATH="$env:USERPROFILE/.cargo/bin;$env:PATH"
+        cmake -S . -B build-windows -G Ninja -DCMAKE_MAKE_PROGRAM=ninja -DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_C_COMPILER_LAUNCHER=ccache -DCMAKE_CXX_COMPILER_LAUNCHER=ccache
+        cmake --build build-windows --target OTRGui --config Release --parallel 10
+        cmake --build build-windows --config Release --parallel 10
+        cd build-windows
+        cpack -G ZIP
+    - name: Upload build
+      uses: actions/upload-artifact@v3
+      with:
+        name: soh-windows
+        path: _packages/*.zip

.github/workflows/gtar

@@ -0,0 +1,2 @@
+#!/bin/sh
+exec sudo /usr/local/bin/gtar.orig "$@"

.github/workflows/macports-deps.txt

@@ -0,0 +1 @@
+libsdl2 +universal libpng +universal glew +universal

.github/workflows/pr-artifacts.yml

@@ -0,0 +1,61 @@
+name: pr-artifacts
+
+on:
+  workflow_run:
+    workflows: [generate-builds]
+    types:
+      - completed
+
+jobs:
+  pr-artifacts:
+    runs-on: ubuntu-latest
+    if: ${{ github.event.workflow_run.event == 'pull_request' }}
+    steps:
+      - id: 'pr-number'
+        uses: actions/github-script@v6
+        with:
+          result-encoding: string
+          script: |
+            const {owner, repo} = context.repo;
+            const pullHeadSHA = '${{github.event.workflow_run.head_sha}}';
+            const pullUserId = ${{github.event.sender.id}};
+            const prNumber = await (async () => {
+              const pulls = await github.rest.pulls.list({owner, repo});
+              for await (const {data} of github.paginate.iterator(pulls)) {
+                for (const pull of data) {
+                  if (pull.head.sha === pullHeadSHA && pull.user.id === pullUserId) {
+                    return pull.number;
+                  }
+                }
+              }
+            })();
+
+            if (!prNumber) {
+              return core.error(`No matching pull request found`);
+            }
+
+            return prNumber;
+      - id: 'artifacts-text'
+        uses: actions/github-script@v6
+        with:
+          result-encoding: string
+          script: |
+            let allArtifacts = await github.rest.actions.listWorkflowRunArtifacts({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              run_id: context.payload.workflow_run.id,
+            });
+
+            return allArtifacts.data.artifacts.reduce((acc, item) => {
+              if (item.name === "assets") return acc;
+              acc += `
+              - [${item.name}.zip](https://nightly.link/${context.repo.owner}/${context.repo.repo}/actions/artifacts/${item.id}.zip)`;
+              return acc;
+            }, '### Build Artifacts');
+      - id: 'add-to-pr'
+        uses: garrettjoecox/pr-section@3.1.0
+        with:
+          repo-token: '${{ secrets.GITHUB_TOKEN }}'
+          pr-number: ${{ steps.pr-number.outputs.result }}
+          section-name: 'artifacts'
+          section-value: '${{ steps.artifacts-text.outputs.result }}'

.gitignore

@@ -0,0 +1,450 @@
+# Cache files
+__pycache__/
+.pyc
+.DS_Store
+
+# Text editor remnants
+.vscode/
+.vs/
+.idea/
+cmake-build-debug
+venv/
+.cache/
+
+# Project-specific ignores
+build/
+expected/
+notes/
+baserom/
+docs/doxygen/
+*.elf
+*.sra
+*.z64
+*.n64
+*.v64
+*.map
+*.dump
+out.txt
+*.sln
+*.vcxproj
+*.vcxproj.user
+*.vcxproj.filters
+
+# Tool artifacts
+tools/mipspro7.2_compiler/
+tools/overlayhelpers/batchdisasm/output/*
+tools/overlayhelpers/batchdisasm/output2/*
+tools/overlayhelpers/batchdisasm/mipsdisasm/*
+tools/disasm/output/*
+tools/asmsplitter/asm/*
+tools/asmsplitter/c/*
+ctx.c
+tools/*dSYM/
+graphs/
+
+# Assets
+*.png
+*.jpg
+*.mdli
+*.anmi
+*.obj
+*.mtl
+*.fbx
+!*_custom*
+.extracted-assets.json
+
+!OTRExporter/assets/**/*.png
+
+# Docs
+!docs/tutorial/
+
+# Per-user configuration
+.python-version
+
+
+## Ignore Visual Studio temporary files, build results, and
+## files generated by popular Visual Studio add-ons.
+##
+## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
+
+# User-specific files
+*.suo
+*.user
+*.userosscache
+*.sln.docstates
+
+# User-specific files (MonoDevelop/Xamarin Studio)
+*.userprefs
+
+# Build results
+[Dd]ebug/
+[Dd]ebugPublic/
+[Rr]elease/
+[Rr]eleases/
+x64/
+x86/
+bld/
+[Bb]in/
+[Oo]bj/
+[Ll]og/
+
+# Visual Studio 2015/2017 cache/options directory
+.vs/
+# Uncomment if you have tasks that create the project's static files in wwwroot
+#wwwroot/
+
+# Visual Studio 2017 auto generated files
+Generated\ Files/
+
+# MSTest test Results
+[Tt]est[Rr]esult*/
+[Bb]uild[Ll]og.*
+
+# NUNIT
+*.VisualState.xml
+TestResult.xml
+
+# Build Results of an ATL Project
+[Dd]ebugPS/
+[Rr]eleasePS/
+dlldata.c
+
+# Benchmark Results
+BenchmarkDotNet.Artifacts/
+
+# .NET Core
+project.lock.json
+project.fragment.lock.json
+artifacts/
+**/Properties/launchSettings.json
+
+# StyleCop
+StyleCopReport.xml
+
+# Files built by Visual Studio
+*_i.c
+*_p.c
+*_i.h
+*.ilk
+*.meta
+*.obj
+*.iobj
+*.pch
+*.pdb
+*.ipdb
+*.pgc
+*.pgd
+*.rsp
+*.sbr
+*.tlb
+*.tli
+*.tlh
+*.tmp
+*.tmp_proj
+*.log
+*.vspscc
+*.vssscc
+.builds
+*.pidb
+*.svclog
+*.scc
+
+# Chutzpah Test files
+_Chutzpah*
+
+# Visual C++ cache files
+ipch/
+*.aps
+*.ncb
+*.opendb
+*.opensdf
+*.sdf
+*.cachefile
+*.VC.db
+*.VC.VC.opendb
+
+# Visual Studio profiler
+*.psess
+*.vsp
+*.vspx
+*.sap
+
+# Visual Studio Trace Files
+*.e2e
+
+# TFS 2012 Local Workspace
+$tf/
+
+# Guidance Automation Toolkit
+*.gpState
+
+# ReSharper is a .NET coding add-in
+_ReSharper*/
+*.[Rr]e[Ss]harper
+*.DotSettings.user
+
+# JustCode is a .NET coding add-in
+.JustCode
+
+# TeamCity is a build add-in
+_TeamCity*
+
+# DotCover is a Code Coverage Tool
+*.dotCover
+
+# AxoCover is a Code Coverage Tool
+.axoCover/*
+!.axoCover/settings.json
+
+# Visual Studio code coverage results
+*.coverage
+*.coveragexml
+
+# NCrunch
+_NCrunch_*
+.*crunch*.local.xml
+nCrunchTemp_*
+
+# MightyMoose
+*.mm.*
+AutoTest.Net/
+
+# Web workbench (sass)
+.sass-cache/
+
+# Installshield output folder
+[Ee]xpress/
+
+# DocProject is a documentation generator add-in
+DocProject/buildhelp/
+DocProject/Help/*.HxT
+DocProject/Help/*.HxC
+DocProject/Help/*.hhc
+DocProject/Help/*.hhk
+DocProject/Help/*.hhp
+DocProject/Help/Html2
+DocProject/Help/html
+
+# Click-Once directory
+publish/
+
+# Publish Web Output
+*.[Pp]ublish.xml
+*.azurePubxml
+# Note: Comment the next line if you want to checkin your web deploy settings,
+# but database connection strings (with potential passwords) will be unencrypted
+*.pubxml
+*.publishproj
+
+# Microsoft Azure Web App publish settings. Comment the next line if you want to
+# checkin your Azure Web App publish settings, but sensitive information contained
+# in these scripts will be unencrypted
+PublishScripts/
+
+# NuGet Packages
+*.nupkg
+# The packages folder can be ignored because of Package Restore
+**/[Pp]ackages/*
+# except build/, which is used as an MSBuild target.
+!**/[Pp]ackages/build/
+# Uncomment if necessary however generally it will be regenerated when needed
+#!**/[Pp]ackages/repositories.config
+# NuGet v3's project.json files produces more ignorable files
+*.nuget.props
+*.nuget.targets
+
+# Microsoft Azure Build Output
+csx/
+*.build.csdef
+
+# Microsoft Azure Emulator
+ecf/
+rcf/
+
+# Windows Store app package directories and files
+AppPackages/
+BundleArtifacts/
+Package.StoreAssociation.xml
+_pkginfo.txt
+*.appx
+
+# Visual Studio cache files
+# files ending in .cache can be ignored
+*.[Cc]ache
+# but keep track of directories ending in .cache
+!*.[Cc]ache/
+
+# Others
+ClientBin/
+~$*
+*~
+*.dbmdl
+*.dbproj.schemaview
+*.jfm
+*.pfx
+*.publishsettings
+orleans.codegen.cs
+
+# Including strong name files can present a security risk
+# (https://github.com/github/gitignore/pull/2483#issue-259490424)
+#*.snk
+
+# Since there are multiple workflows, uncomment next line to ignore bower_components
+# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
+#bower_components/
+
+# RIA/Silverlight projects
+Generated_Code/
+
+# Backup & report files from converting an old project file
+# to a newer Visual Studio version. Backup files are not needed,
+# because we have git ;-)
+_UpgradeReport_Files/
+Backup*/
+UpgradeLog*.XML
+UpgradeLog*.htm
+ServiceFabricBackup/
+*.rptproj.bak
+
+# SQL Server files
+*.mdf
+*.ldf
+*.ndf
+
+# Business Intelligence projects
+*.rdl.data
+*.bim.layout
+*.bim_*.settings
+*.rptproj.rsuser
+
+# Microsoft Fakes
+FakesAssemblies/
+
+# GhostDoc plugin setting file
+*.GhostDoc.xml
+
+# Node.js Tools for Visual Studio
+.ntvs_analysis.dat
+node_modules/
+
+# Visual Studio 6 build log
+*.plg
+
+# Visual Studio 6 workspace options file
+*.opt
+
+# Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
+*.vbw
+
+# Visual Studio LightSwitch build output
+**/*.HTMLClient/GeneratedArtifacts
+**/*.DesktopClient/GeneratedArtifacts
+**/*.DesktopClient/ModelManifest.xml
+**/*.Server/GeneratedArtifacts
+**/*.Server/ModelManifest.xml
+_Pvt_Extensions
+
+# Paket dependency manager
+.paket/paket.exe
+paket-files/
+
+# FAKE - F# Make
+.fake/
+
+# JetBrains Rider
+.idea/
+*.sln.iml
+
+# CodeRush
+.cr/
+
+# Python Tools for Visual Studio (PTVS)
+__pycache__/
+*.pyc
+
+# Cake - Uncomment if you are using it
+# tools/**
+# !tools/packages.config
+
+# Tabs Studio
+*.tss
+
+# Telerik's JustMock configuration file
+*.jmconfig
+
+# BizTalk build output
+*.btp.cs
+*.btm.cs
+*.odx.cs
+*.xsd.cs
+
+# OpenCover UI analysis results
+OpenCover/
+
+# Azure Stream Analytics local run output
+ASALocalRun/
+
+# MSBuild Binary and Structured Log
+*.binlog
+
+# NVidia Nsight GPU debugger configuration file
+*.nvuser
+
+# MFractors (Xamarin productivity tool) working folder
+.mfractor/
+
+*.out
+*.o
+*.d
+lib/libgfxd/libgfxd.a
+ExporterTest/ExporterTest.a
+ZAPDUtils/ZAPDUtils.a
+.vscode/
+build/
+external/
+ZAPDUtils/build/
+ZAPD/BuildInfo.h
+
+DebugObj/*
+ReleaseObj/*
+.tags
+tags
+oot.otr
+oot-mq.otr
+*.sav
+shipofharkinian.ini
+shipofharkinian.json
+imgui.ini
+
+# Switch Stuff
+
+*.nro
+*.nacp
+ZAPDTR/ZAPDUtils/lib/*
+!/soh/icon.jpg
+
+# Xcode
+xcuserdata/
+*.xcconfig
+*.xcodeproj/*
+!*.xcodeproj/project.pbxproj
+!*.xcodeproj/xcshareddata/
+!*.xcworkspace/contents.xcworkspacedata
+/*.gcno
+**/xcshareddata/WorkspaceSettings.xcsettings
+
+# cmake
+CMakeLists.txt.user
+CMakeCache.txt
+CMakeFiles
+CMakeScripts
+Testing
+Makefile
+cmake_install.cmake
+install_manifest.txt
+compile_commands.json
+CTestTestfile.cmake
+_deps
+*/extract_assets_cmake*
+/build*
+build.c

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "libultraship"]
+	path = libultraship
+	url = https://github.com/kenix3/libultraship.git

BUILDING.md

@@ -0,0 +1,232 @@
+# Building Ship of Harkinian
+
+## Windows
+
+Requires:
+  * At least 8GB of RAM (machines with 4GB have seen complier failures)
+  * Visual Studio 2022 Community Edition with the C++ feature set
+  * One of the Windows SDKs that comes with Visual Studio, for example the current Windows 10 version 10.0.19041.0
+  * The `MSVC v142 - VS 2019 C++ build tools` component of Visual Studio
+  * Python 3 (can be installed manually or as part of Visual Studio)
+  * Git (can be installed manually or as part of Visual Studio)
+  * Cmake (can be installed via chocolatey or manually)
+
+During installation, check the "Desktop development with C++" feature set:
+
+![image](https://user-images.githubusercontent.com/30329717/183511274-d11aceea-7900-46ec-acb6-3f2cc110021a.png)
+Doing so should also check one of the Windows SDKs by default.  Then, in the installation details in the right-hand column, make sure you also check the v142 toolset. 
+
+You can also find the v142 toolset by searching through the individual components tab:  
+
+![image](https://user-images.githubusercontent.com/30329717/183521169-ead6a73b-a1bf-4e99-aab8-441746d8f08e.png)
+While you're there, you can also install Python 3 and Git if needed.
+
+1. Clone the Ship of Harkinian repository
+
+_Note: Be sure to either clone with the ``--recursive`` flag or do ``git submodule init`` after cloning to pull in the libultraship submodule!_
+
+2. Place one or more [compatible](#compatible-roms) roms in the `OTRExporter` directory with namings of your choice
+
+_Note: Instructions assume using powershell_
+```powershell
+# Navigate to the Shipwright repo within powershell. ie: cd "C:\yourpath\Shipwright"
+cd Shipwright
+
+# Setup cmake project
+& 'C:\Program Files\CMake\bin\cmake' -S . -B "build/x64" -G "Visual Studio 17 2022" -T v142 -A x64 # -DCMAKE_BUILD_TYPE:STRING=Release (if you're packaging)
+# or for VS2019
+& 'C:\Program Files\CMake\bin\cmake' -S . -B "build/x64" -G "Visual Studio 16 2019" -T v142 -A x64
+# Extract assets & generate OTR (run this anytime you need to regenerate OTR)
+& 'C:\Program Files\CMake\bin\cmake.exe' --build .\build\x64 --target ExtractAssets # --config Release (if you're packaging)
+# Compile project
+& 'C:\Program Files\CMake\bin\cmake.exe' --build .\build\x64 # --config Release (if you're packaging)
+
+# Now you can run the executable in .\build\x64
+
+# If you need to clean the project you can run
+& 'C:\Program Files\CMake\bin\cmake.exe' --build .\build\x64 --target clean
+```
+
+### Developing SoH
+With the cmake build system you have two options for working on the project:
+
+#### Visual Studio
+To develop using Visual Studio you only need to use cmake to generate the solution file:
+```powershell
+# Generates Ship.sln at `build/x64` for Visual Studio 2022
+& 'C:\Program Files\CMake\bin\cmake' -S . -B "build/x64" -G "Visual Studio 17 2022" -T v142 -A x64
+# or for Visual Studio 2019
+& 'C:\Program Files\CMake\bin\cmake' -S . -B "build/x64" -G "Visual Studio 16 2019" -T v142 -A x64
+```
+
+#### Visual Studio Code or another editor
+To develop using Visual Studio Code or another editor you only need to open the repository in it.
+To build you'll need to follow the instructions from the building section.
+
+_Note: If you're using Visual Studio Code, the [cpack plugin](https://marketplace.visualstudio.com/items?itemName=ms-vscode.cmake-tools) makes it very easy to just press run and debug._
+
+_Experimental: You can also use another build system entirely rather than MSVC like [Ninja](https://ninja-build.org/) for possibly better performance._
+
+
+### Generating the distributable
+After compiling the project you can generate the distributable by running:
+```powershell
+# Go to build folder
+cd "build/x64"
+# Generate
+& 'C:\Program Files\CMake\bin\cpack.exe' -G ZIP
+```
+
+## Linux
+Requires `gcc >= 10, x11, curl, python3, sdl2 >= 2.0.22, libpng, glew >= 2.2, ninja, cmake, lld`
+
+**Important: For maximum performance make sure you have ninja build tools installed!**
+
+_Note: If you're using Visual Studio Code, the [cpack plugin](https://marketplace.visualstudio.com/items?itemName=ms-vscode.cmake-tools) makes it very easy to just press run and debug._
+
+```bash
+# Clone the repo
+git clone https://github.com/HarbourMasters/Shipwright.git
+cd Shipwright
+# Clone the submodule libultraship
+git submodule update --init
+# Copy the baserom to the OTRExporter folder
+cp <path to your ROM> OTRExporter
+# Generate Ninja project
+cmake -H. -Bbuild-cmake -GNinja # -DCMAKE_BUILD_TYPE:STRING=Release (if you're packaging) -DPython3_EXECUTABLE=$(which python3) (if you are using non-standard Python installations such as PyEnv)
+# Extract assets & generate OTR (run this anytime you need to regenerate OTR)
+cmake --build build-cmake --target ExtractAssets
+# Compile the project
+cmake --build build-cmake # --config Release (if you're packaging)
+
+# Now you can run the executable in ./build-cmake/soh/soh.elf
+# To develop the project open the repository in VSCode (or your preferred editor)
+
+# If you need to clean the project you can run
+cmake --build build-cmake --target clean
+```
+
+### Generating a distributable
+After compiling the project you can generate a distributable by running of the following:
+```bash
+# Go to build folder
+cd build-cmake
+# Generate
+cpack -G DEB
+cpack -G ZIP
+cpack -G External (creates appimage)
+```
+
+## macOS
+Requires Xcode (or xcode-tools) && `sdl2, libpng, glew, ninja, cmake` (can be installed via homebrew, macports, etc)
+
+**Important: For maximum performance make sure you have ninja build tools installed!**
+
+_Note: If you're using Visual Studio Code, the [cpack plugin](https://marketplace.visualstudio.com/items?itemName=ms-vscode.cmake-tools) makes it very easy to just press run and debug._
+
+```bash
+# Clone the repo
+git clone https://github.com/HarbourMasters/Shipwright.git
+cd ShipWright
+# Clone the submodule libultraship
+git submodule update --init
+# Copy the baserom to the OTRExporter folder
+cp <path to your ROM> OTRExporter
+# Generate Ninja project
+cmake -H. -Bbuild-cmake -GNinja # -DCMAKE_BUILD_TYPE:STRING=Release (if you're packaging)
+# Extract assets & generate OTR (run this anytime you need to regenerate OTR)
+cmake --build build-cmake --target ExtractAssets
+# Compile the project
+cmake --build build-cmake # --config Release (if you're packaging)
+
+# Copy oot.otr into the Application Support directory
+cp build-cmake/soh/oot.otr ~/Library/Application\ Support/com.shipofharkinian.soh/
+
+# Now you can run the executable file:
+./build-cmake/soh/soh-macos
+# To develop the project open the repository in VSCode (or your preferred editor)
+
+# If you need to clean the project you can run
+cmake --build build-cmake --target clean
+```
+
+### Generating a distributable
+After compiling the project you can generate a distributable by running of the following:
+```bash
+# Go to build folder
+cd build-cmake
+# Generate
+cpack
+```
+
+## Switch
+1. Requires that your build machine is setup with the tools necessary for your platform above
+2. Requires that you have the switch build tools installed 
+3. Clone the Ship of Harkinian repository
+4. Place one or more [compatible](#compatible-roms) roms in the `OTRExporter` directory with namings of your choice
+
+```bash
+cd Shipwright
+# Setup cmake project for your host machine
+cmake -H. -Bbuild-cmake -GNinja
+# Extract assets & generate OTR (run this anytime you need to regenerate OTR)
+cmake --build build-cmake --target ExtractAssets
+# Setup cmake project for building for Switch
+cmake -H. -Bbuild-switch -GNinja -DCMAKE_TOOLCHAIN_FILE=/opt/devkitpro/cmake/Switch.cmake
+# Build project and generate nro
+cmake --build build-switch --target soh_nro
+
+# Now you can run the executable in ./build-switch/soh/soh.nro
+# To develop the project open the repository in VSCode (or your preferred editor)
+```
+
+## Wii U
+1. Requires that your build machine is setup with the tools necessary for your platform above
+2. Requires that you have the Wii U build tools installed 
+3. Clone the Ship of Harkinian repository
+4. Place one or more [compatible](#compatible-roms) roms in the `OTRExporter` directory with namings of your choice
+
+```bash
+cd Shipwright
+# Setup cmake project for your host machine
+cmake -H. -Bbuild-cmake -GNinja
+# Extract assets & generate OTR (run this anytime you need to regenerate OTR)
+cmake --build build-cmake --target ExtractAssets
+# Setup cmake project for building for Wii U
+cmake -H. -Bbuild-wiiu -GNinja -DCMAKE_TOOLCHAIN_FILE=/opt/devkitpro/cmake/WiiU.cmake # -DCMAKE_BUILD_TYPE:STRING=Release (if you're packaging)
+# Build project and generate rpx
+cmake --build build-wiiu --target soh # --target soh_wuhb (for building .wuhb) 
+
+# Now you can run the executable in ./build-wiiu/soh/soh.rpx or the Wii U Homebrew Bundle in ./build-wiiu/soh/soh.wuhb
+# To develop the project open the repository in VSCode (or your preferred editor)
+```
+
+# Compatible Roms
+```
+OOT_PAL_GC      checksum 0x09465AC3
+OOT_PAL_GC_DBG1 checksum 0x871E1C92 (debug non-master quest)
+```
+
+# OTRExporter Usage
+
+The OTRExporter exports an `oot.otr` archive file which Ship of Harkinian requires to play.
+
+Use the `extract_assets.py` script file to run the exporter using any of the following methods:
+1) Double click on the script after placing one or more roms in the directory.
+2) Drag & Drop a rom onto the script.
+3) In a terminal run `python3 extract_assets.py` after placing one or more roms in the directory.
+4) In a terminal run `python3 extract_assets.py <path_to_rom>`
+
+If the script finds multiple roms the user is prompted which to use. Selection is done using the number keys and then pressing the carriage return key.
+
+## Getting CI to work on your fork
+
+The CI works via [Github Actions](https://github.com/features/actions) where we mostly make use of machines hosted by Github; except for the very first step of the CI process called "Extract assets". This steps extracts assets from the game file and generates an "assets" folder in `soh/`.
+
+To get this step working on your fork, you'll need to add a machine to your own repository as a self-hosted runner via "Settings > Actions > Runners" in your repository settings. Make sure to add the 'asset-builder' tag to your newly added runner to assign it to run this step. To setup your runner as a service read the docs [here](https://docs.github.com/en/actions/hosting-your-own-runners/configuring-the-self-hosted-runner-application-as-a-service?platform=linux).
+
+### Runner on Windows
+You'll have to enable the ability to run unsigned scripts through PowerShell. To do this, open Powershell as administrator and run `set-executionpolicy remotesigned`. Most dependencies get installed as part of the CI process. You will also need to seperately install 7z and add it to the PATH so `7z` can be run as a command. [Chocolatey](https://chocolatey.org/) or other package managers can be used to install it easily.
+
+### Runner on UNIX systems
+If you're on macOS or Linux take a look at `macports-deps.txt` or `apt-deps.txt` to see the dependencies expected to be on your machine.

CMake/Default.cmake

@@ -0,0 +1,65 @@
+################################################################################
+# Command for variable_watch. This command issues error message, if a variable
+# is changed. If variable PROPERTY_READER_GUARD_DISABLED is TRUE nothing happens
+#     variable_watch(<variable> property_reader_guard)
+################################################################################
+function(property_reader_guard VARIABLE ACCESS VALUE CURRENT_LIST_FILE STACK)
+    if("${PROPERTY_READER_GUARD_DISABLED}")
+        return()
+    endif()
+
+    if("${ACCESS}" STREQUAL "MODIFIED_ACCESS")
+        message(FATAL_ERROR
+            " Variable ${VARIABLE} is not supposed to be changed.\n"
+            " It is used only for reading target property ${VARIABLE}.\n"
+            " Use\n"
+            "     set_target_properties(\"<target>\" PROPERTIES \"${VARIABLE}\" \"<value>\")\n"
+            " or\n"
+            "     set_target_properties(\"<target>\" PROPERTIES \"${VARIABLE}_<CONFIG>\" \"<value>\")\n"
+            " instead.\n")
+    endif()
+endfunction()
+
+################################################################################
+# Create variable <name> with generator expression that expands to value of
+# target property <name>_<CONFIG>. If property is empty or not set then property
+# <name> is used instead. Variable <name> has watcher property_reader_guard that
+# doesn't allow to edit it.
+#     create_property_reader(<name>)
+# Input:
+#     name - Name of watched property and output variable
+################################################################################
+function(create_property_reader NAME)
+    set(PROPERTY_READER_GUARD_DISABLED TRUE)
+    set(CONFIG_VALUE "$<TARGET_GENEX_EVAL:${PROPS_TARGET},$<TARGET_PROPERTY:${PROPS_TARGET},${NAME}_$<UPPER_CASE:$<CONFIG>>>>")
+    set(IS_CONFIG_VALUE_EMPTY "$<STREQUAL:${CONFIG_VALUE},>")
+    set(GENERAL_VALUE "$<TARGET_GENEX_EVAL:${PROPS_TARGET},$<TARGET_PROPERTY:${PROPS_TARGET},${NAME}>>")
+    set("${NAME}" "$<IF:${IS_CONFIG_VALUE_EMPTY},${GENERAL_VALUE},${CONFIG_VALUE}>" PARENT_SCOPE)
+    variable_watch("${NAME}" property_reader_guard)
+endfunction()
+
+################################################################################
+# Set property $<name>_${PROPS_CONFIG_U} of ${PROPS_TARGET} to <value>
+#     set_config_specific_property(<name> <value>)
+# Input:
+#     name  - Prefix of property name
+#     value - New value
+################################################################################
+function(set_config_specific_property NAME VALUE)
+    set_target_properties("${PROPS_TARGET}" PROPERTIES "${NAME}_${PROPS_CONFIG_U}" "${VALUE}")
+endfunction()
+
+################################################################################
+
+create_property_reader("TARGET_NAME")
+create_property_reader("OUTPUT_DIRECTORY")
+
+set_config_specific_property("TARGET_NAME" "${PROPS_TARGET}")
+set_config_specific_property("OUTPUT_NAME" "${TARGET_NAME}")
+set_config_specific_property("ARCHIVE_OUTPUT_NAME" "${TARGET_NAME}")
+set_config_specific_property("LIBRARY_OUTPUT_NAME" "${TARGET_NAME}")
+set_config_specific_property("RUNTIME_OUTPUT_NAME" "${TARGET_NAME}")
+
+set_config_specific_property("ARCHIVE_OUTPUT_DIRECTORY" "${OUTPUT_DIRECTORY}")
+set_config_specific_property("LIBRARY_OUTPUT_DIRECTORY" "${OUTPUT_DIRECTORY}")
+set_config_specific_property("RUNTIME_OUTPUT_DIRECTORY" "${OUTPUT_DIRECTORY}")

CMake/DefaultCXX.cmake

@@ -0,0 +1,12 @@
+include("${CMAKE_CURRENT_LIST_DIR}/Default.cmake")
+
+set_config_specific_property("OUTPUT_DIRECTORY" "${CMAKE_SOURCE_DIR}$<$<NOT:$<STREQUAL:${CMAKE_VS_PLATFORM_NAME},Win32>>:/${CMAKE_VS_PLATFORM_NAME}>/${PROPS_CONFIG}")
+
+if(MSVC)
+    create_property_reader("DEFAULT_CXX_EXCEPTION_HANDLING")
+    create_property_reader("DEFAULT_CXX_DEBUG_INFORMATION_FORMAT")
+
+    set_target_properties("${PROPS_TARGET}" PROPERTIES MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>DLL")
+    set_config_specific_property("DEFAULT_CXX_EXCEPTION_HANDLING" "/EHsc")
+    set_config_specific_property("DEFAULT_CXX_DEBUG_INFORMATION_FORMAT" "/Zi")
+endif()

CMake/Packaging-2.cmake

@@ -0,0 +1,30 @@
+set(CPACK_ARCHIVE_COMPONENT_INSTALL ON)
+set(CPACK_COMPONENT_INCLUDE_TOPLEVEL_DIRECTORY 0)
+set(CPACK_COMPONENTS_ALL "ship" "appimage")
+
+if (NOT CPACK_GENERATOR STREQUAL "External")
+  list(REMOVE_ITEM CPACK_COMPONENTS_ALL "appimage")
+endif()
+
+if (CPACK_GENERATOR MATCHES "DEB|RPM")
+# https://unix.stackexchange.com/a/11552/254512
+set(CPACK_PACKAGING_INSTALL_PREFIX "/opt/ship/bin")#/${CMAKE_PROJECT_VERSION}")
+set(CPACK_COMPONENT_INCLUDE_TOPLEVEL_DIRECTORY 0)
+elseif (CPACK_GENERATOR MATCHES "ZIP")
+set(CPACK_PACKAGING_INSTALL_PREFIX "")
+endif()
+
+if (CPACK_GENERATOR MATCHES "External")
+set(CPACK_ARCHIVE_COMPONENT_INSTALL ON)
+SET(CPACK_MONOLITHIC_INSTALL 1)
+set(CPACK_PACKAGING_INSTALL_PREFIX "/usr/bin")
+endif()
+
+if (CPACK_GENERATOR MATCHES "Bundle")
+    set(CPACK_BUNDLE_NAME "soh")
+    set(CPACK_BUNDLE_PLIST "macosx/Info.plist")
+    set(CPACK_BUNDLE_ICON "macosx/soh.icns")
+    set(CPACK_BUNDLE_STARTUP_COMMAND "../soh/macosx/soh-macos.sh")
+    set(CPACK_BUNDLE_APPLE_CERT_APP "-")
+endif()
+

CMake/Packaging.cmake

@@ -0,0 +1,90 @@
+# these are cache variables, so they could be overwritten with -D,
+
+set(CPACK_PACKAGE_NAME "${PROJECT_NAME}"
+    CACHE STRING "The resulting package name"
+)
+
+set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Simple C++ application"
+    CACHE STRING "Package description for the package metadata"
+)
+set(CPACK_PACKAGE_VENDOR "Some Company")
+
+set(CPACK_VERBATIM_VARIABLES YES)
+
+set(CPACK_PACKAGE_INSTALL_DIRECTORY ${CPACK_PACKAGE_NAME})
+SET(CPACK_OUTPUT_FILE_PREFIX "${CMAKE_SOURCE_DIR}/_packages")
+
+set(CPACK_PACKAGE_VERSION_MAJOR ${PROJECT_VERSION_MAJOR})
+set(CPACK_PACKAGE_VERSION_MINOR ${PROJECT_VERSION_MINOR})
+set(CPACK_PACKAGE_VERSION_PATCH ${PROJECT_VERSION_PATCH})
+set(CPACK_PACKAGE_VERSION "${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH}")
+
+set(CPACK_PACKAGE_CONTACT "YOUR@E-MAIL.net")
+set(CPACK_DEBIAN_PACKAGE_MAINTAINER "YOUR NAME")
+
+#set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE")
+set(CPACK_RESOURCE_FILE_README "${CMAKE_SOURCE_DIR}/README.md")
+
+if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
+set(CPACK_SYSTEM_NAME ${LSB_RELEASE_CODENAME_SHORT})
+# package name for deb
+# if set, then instead of some-application-0.9.2-Linux.deb
+# you'll get some-application_0.9.2_amd64.deb (note the underscores too)
+#set(CPACK_DEBIAN_FILE_NAME DEB-DEFAULT)
+execute_process(COMMAND dpkg --print-architecture OUTPUT_VARIABLE ARCHITECTURE OUTPUT_STRIP_TRAILING_WHITESPACE)
+set( CPACK_DEBIAN_FILE_NAME ${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}-${CPACK_SYSTEM_NAME}-${ARCHITECTURE}.deb )
+# if you want every group to have its own package,
+# although the same happens if this is not sent (so it defaults to ONE_PER_GROUP)
+# and CPACK_DEB_COMPONENT_INSTALL is set to YES
+set(CPACK_COMPONENTS_GROUPING ALL_COMPONENTS_IN_ONE)#ONE_PER_GROUP)
+# without this you won't be able to pack only specified component
+set(CPACK_DEB_COMPONENT_INSTALL YES)
+
+set(CPACK_EXTERNAL_ENABLE_STAGING YES)
+set(CPACK_EXTERNAL_PACKAGE_SCRIPT "${PROJECT_BINARY_DIR}/appimage-generate.cmake")
+
+file(GENERATE
+  OUTPUT "${PROJECT_BINARY_DIR}/appimage-generate.cmake"
+  CONTENT [[
+include(CMakePrintHelpers)
+cmake_print_variables(CPACK_TEMPORARY_DIRECTORY)
+cmake_print_variables(CPACK_TOPLEVEL_DIRECTORY)
+cmake_print_variables(CPACK_PACKAGE_DIRECTORY)
+cmake_print_variables(CPACK_PACKAGE_FILE_NAME)
+
+find_program(LINUXDEPLOY_EXECUTABLE
+  NAMES linuxdeploy linuxdeploy-x86_64.AppImage
+  PATHS ${CPACK_PACKAGE_DIRECTORY}/linuxdeploy)
+
+if (NOT LINUXDEPLOY_EXECUTABLE)
+  message(STATUS "Downloading linuxdeploy")
+  set(LINUXDEPLOY_EXECUTABLE ${CPACK_PACKAGE_DIRECTORY}/linuxdeploy/linuxdeploy)
+  file(DOWNLOAD 
+      https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-x86_64.AppImage
+      ${LINUXDEPLOY_EXECUTABLE}
+      INACTIVITY_TIMEOUT 10
+      LOG ${CPACK_PACKAGE_DIRECTORY}/linuxdeploy/download.log
+      STATUS LINUXDEPLOY_DOWNLOAD)
+  execute_process(COMMAND chmod +x ${LINUXDEPLOY_EXECUTABLE} COMMAND_ECHO STDOUT)
+endif()
+
+execute_process(
+  COMMAND
+    ${CMAKE_COMMAND} -E env
+      OUTPUT=${CPACK_PACKAGE_FILE_NAME}.appimage
+      VERSION=$<IF:$<BOOL:${CPACK_PACKAGE_VERSION}>,${CPACK_PACKAGE_VERSION},0.1.0>
+    ${LINUXDEPLOY_EXECUTABLE}
+    --appimage-extract-and-run
+    --appdir=${CPACK_TEMPORARY_DIRECTORY}
+    --executable=$<TARGET_FILE:soh>
+    $<$<BOOL:$<TARGET_PROPERTY:soh,APPIMAGE_DESKTOP_FILE>>:--desktop-file=$<TARGET_PROPERTY:soh,APPIMAGE_DESKTOP_FILE>>
+    $<$<BOOL:$<TARGET_PROPERTY:soh,APPIMAGE_ICON_FILE>>:--icon-file=$<TARGET_PROPERTY:soh,APPIMAGE_ICON_FILE>>
+    --output=appimage
+    # --verbosity=2
+)
+]])
+
+endif()
+
+include(CPack)
+

CMake/Utils.cmake

@@ -0,0 +1,248 @@
+# utils file for projects came from visual studio solution with cmake-converter.
+
+################################################################################
+# Wrap each token of the command with condition
+################################################################################
+cmake_policy(PUSH)
+cmake_policy(SET CMP0054 NEW)
+macro(prepare_commands)
+    unset(TOKEN_ROLE)
+    unset(COMMANDS)
+    foreach(TOKEN ${ARG_COMMANDS})
+        if("${TOKEN}" STREQUAL "COMMAND")
+            set(TOKEN_ROLE "KEYWORD")
+        elseif("${TOKEN_ROLE}" STREQUAL "KEYWORD")
+            set(TOKEN_ROLE "CONDITION")
+        elseif("${TOKEN_ROLE}" STREQUAL "CONDITION")
+            set(TOKEN_ROLE "COMMAND")
+        elseif("${TOKEN_ROLE}" STREQUAL "COMMAND")
+            set(TOKEN_ROLE "ARG")
+        endif()
+
+        if("${TOKEN_ROLE}" STREQUAL "KEYWORD")
+            list(APPEND COMMANDS "${TOKEN}")
+        elseif("${TOKEN_ROLE}" STREQUAL "CONDITION")
+            set(CONDITION ${TOKEN})
+        elseif("${TOKEN_ROLE}" STREQUAL "COMMAND")
+            list(APPEND COMMANDS "$<$<NOT:${CONDITION}>:${DUMMY}>$<${CONDITION}:${TOKEN}>")
+        elseif("${TOKEN_ROLE}" STREQUAL "ARG")
+            list(APPEND COMMANDS "$<${CONDITION}:${TOKEN}>")
+        endif()
+    endforeach()
+endmacro()
+cmake_policy(POP)
+
+################################################################################
+# Transform all the tokens to absolute paths
+################################################################################
+macro(prepare_output)
+    unset(OUTPUT)
+    foreach(TOKEN ${ARG_OUTPUT})
+        if(IS_ABSOLUTE ${TOKEN})
+            list(APPEND OUTPUT "${TOKEN}")
+        else()
+            list(APPEND OUTPUT "${CMAKE_CURRENT_SOURCE_DIR}/${TOKEN}")
+        endif()
+    endforeach()
+endmacro()
+
+################################################################################
+# Parse add_custom_command_if args.
+#
+# Input:
+#     PRE_BUILD  - Pre build event option
+#     PRE_LINK   - Pre link event option
+#     POST_BUILD - Post build event option
+#     TARGET     - Target
+#     OUTPUT     - List of output files
+#     DEPENDS    - List of files on which the command depends
+#     COMMANDS   - List of commands(COMMAND condition1 commannd1 args1 COMMAND
+#                  condition2 commannd2 args2 ...)
+# Output:
+#     OUTPUT     - Output files
+#     DEPENDS    - Files on which the command depends
+#     COMMENT    - Comment
+#     PRE_BUILD  - TRUE/FALSE
+#     PRE_LINK   - TRUE/FALSE
+#     POST_BUILD - TRUE/FALSE
+#     TARGET     - Target name
+#     COMMANDS   - Prepared commands(every token is wrapped in CONDITION)
+#     NAME       - Unique name for custom target
+#     STEP       - PRE_BUILD/PRE_LINK/POST_BUILD
+################################################################################
+function(add_custom_command_if_parse_arguments)
+    cmake_parse_arguments("ARG" "PRE_BUILD;PRE_LINK;POST_BUILD" "TARGET;COMMENT" "DEPENDS;OUTPUT;COMMANDS" ${ARGN})
+
+    if(WIN32)
+        set(DUMMY "cd.")
+    elseif(UNIX)
+        set(DUMMY "true")
+    endif()
+
+    prepare_commands()
+    prepare_output()
+
+    set(DEPENDS "${ARG_DEPENDS}")
+    set(COMMENT "${ARG_COMMENT}")
+    set(PRE_BUILD "${ARG_PRE_BUILD}")
+    set(PRE_LINK "${ARG_PRE_LINK}")
+    set(POST_BUILD "${ARG_POST_BUILD}")
+    set(TARGET "${ARG_TARGET}")
+    if(PRE_BUILD)
+        set(STEP "PRE_BUILD")
+    elseif(PRE_LINK)
+        set(STEP "PRE_LINK")
+    elseif(POST_BUILD)
+        set(STEP "POST_BUILD")
+    endif()
+    set(NAME "${TARGET}_${STEP}")
+
+    set(OUTPUT "${OUTPUT}" PARENT_SCOPE)
+    set(DEPENDS "${DEPENDS}" PARENT_SCOPE)
+    set(COMMENT "${COMMENT}" PARENT_SCOPE)
+    set(PRE_BUILD "${PRE_BUILD}" PARENT_SCOPE)
+    set(PRE_LINK "${PRE_LINK}" PARENT_SCOPE)
+    set(POST_BUILD "${POST_BUILD}" PARENT_SCOPE)
+    set(TARGET "${TARGET}" PARENT_SCOPE)
+    set(COMMANDS "${COMMANDS}" PARENT_SCOPE)
+    set(STEP "${STEP}" PARENT_SCOPE)
+    set(NAME "${NAME}" PARENT_SCOPE)
+endfunction()
+
+################################################################################
+# Add conditional custom command
+#
+# Generating Files
+# The first signature is for adding a custom command to produce an output:
+#     add_custom_command_if(
+#         <OUTPUT output1 [output2 ...]>
+#         <COMMANDS>
+#         <COMMAND condition command1 [args1...]>
+#         [COMMAND condition command2 [args2...]]
+#         [DEPENDS [depends...]]
+#         [COMMENT comment]
+#
+# Build Events
+#     add_custom_command_if(
+#         <TARGET target>
+#         <PRE_BUILD | PRE_LINK | POST_BUILD>
+#         <COMMAND condition command1 [args1...]>
+#         [COMMAND condition command2 [args2...]]
+#         [COMMENT comment]
+#
+# Input:
+#     output     - Output files the command is expected to produce
+#     condition  - Generator expression for wrapping the command
+#     command    - Command-line(s) to execute at build time.
+#     args       - Command`s args
+#     depends    - Files on which the command depends
+#     comment    - Display the given message before the commands are executed at
+#                  build time.
+#     PRE_BUILD  - Run before any other rules are executed within the target
+#     PRE_LINK   - Run after sources have been compiled but before linking the
+#                  binary
+#     POST_BUILD - Run after all other rules within the target have been
+#                  executed
+################################################################################
+function(add_custom_command_if)
+    add_custom_command_if_parse_arguments(${ARGN})
+
+    if(OUTPUT AND TARGET)
+        message(FATAL_ERROR  "Wrong syntax. A TARGET and OUTPUT can not both be specified.")
+    endif()
+
+    if(OUTPUT)
+        add_custom_command(OUTPUT ${OUTPUT}
+                           ${COMMANDS}
+                           DEPENDS ${DEPENDS}
+                           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+                           COMMENT ${COMMENT})
+    elseif(TARGET)
+        if(PRE_BUILD AND NOT ${CMAKE_GENERATOR} MATCHES "Visual Studio")
+            add_custom_target(
+                ${NAME}
+                ${COMMANDS}
+                WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+                COMMENT ${COMMENT})
+            add_dependencies(${TARGET} ${NAME})
+        else()
+            add_custom_command(
+                TARGET ${TARGET}
+                ${STEP}
+                ${COMMANDS}
+                WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+                COMMENT ${COMMENT})
+        endif()
+    else()
+        message(FATAL_ERROR "Wrong syntax. A TARGET or OUTPUT must be specified.")
+    endif()
+endfunction()
+
+################################################################################
+# Use props file for a target and configs
+#     use_props(<target> <configs...> <props_file>)
+# Inside <props_file> there are following variables:
+#     PROPS_TARGET   - <target>
+#     PROPS_CONFIG   - One of <configs...>
+#     PROPS_CONFIG_U - Uppercase PROPS_CONFIG
+# Input:
+#     target      - Target to apply props file
+#     configs     - Build configurations to apply props file
+#     props_file  - CMake script
+################################################################################
+macro(use_props TARGET CONFIGS PROPS_FILE)
+    set(PROPS_TARGET "${TARGET}")
+    foreach(PROPS_CONFIG ${CONFIGS})
+        string(TOUPPER "${PROPS_CONFIG}" PROPS_CONFIG_U)
+
+        get_filename_component(ABSOLUTE_PROPS_FILE "${PROPS_FILE}" ABSOLUTE BASE_DIR "${CMAKE_CURRENT_LIST_DIR}")
+        if(EXISTS "${ABSOLUTE_PROPS_FILE}")
+            include("${ABSOLUTE_PROPS_FILE}")
+        else()
+            message(WARNING "Corresponding cmake file from props \"${ABSOLUTE_PROPS_FILE}\" doesn't exist")
+        endif()
+    endforeach()
+endmacro()
+
+################################################################################
+# Add compile options to source file
+#     source_file_compile_options(<source_file> [compile_options...])
+# Input:
+#     source_file     - Source file
+#     compile_options - Options to add to COMPILE_FLAGS property
+################################################################################
+function(source_file_compile_options SOURCE_FILE)
+    if("${ARGC}" LESS_EQUAL "1")
+        return()
+    endif()
+
+    get_source_file_property(COMPILE_OPTIONS "${SOURCE_FILE}" COMPILE_OPTIONS)
+
+    if(COMPILE_OPTIONS)
+        list(APPEND COMPILE_OPTIONS ${ARGN})
+    else()
+        set(COMPILE_OPTIONS "${ARGN}")
+    endif()
+
+    set_source_files_properties("${SOURCE_FILE}" PROPERTIES COMPILE_OPTIONS "${COMPILE_OPTIONS}")
+endfunction()
+
+################################################################################
+# Default properties of visual studio projects
+################################################################################
+set(DEFAULT_CXX_PROPS "${CMAKE_CURRENT_LIST_DIR}/DefaultCXX.cmake")
+
+function(get_linux_lsb_release_information)
+    find_program(LSB_RELEASE_EXEC lsb_release)
+    if(NOT LSB_RELEASE_EXEC)
+        message(FATAL_ERROR "Could not detect lsb_release executable, can not gather required information")
+    endif()
+
+    execute_process(COMMAND "${LSB_RELEASE_EXEC}" --short --id OUTPUT_VARIABLE LSB_RELEASE_ID_SHORT OUTPUT_STRIP_TRAILING_WHITESPACE)
+    execute_process(COMMAND "${LSB_RELEASE_EXEC}" --short --release OUTPUT_VARIABLE LSB_RELEASE_VERSION_SHORT OUTPUT_STRIP_TRAILING_WHITESPACE)
+    execute_process(COMMAND "${LSB_RELEASE_EXEC}" --short --codename OUTPUT_VARIABLE LSB_RELEASE_CODENAME_SHORT OUTPUT_STRIP_TRAILING_WHITESPACE)
+
+    set(LSB_RELEASE_ID_SHORT "${LSB_RELEASE_ID_SHORT}" PARENT_SCOPE)
+    set(LSB_RELEASE_VERSION_SHORT "${LSB_RELEASE_VERSION_SHORT}" PARENT_SCOPE)
+    set(LSB_RELEASE_CODENAME_SHORT "${LSB_RELEASE_CODENAME_SHORT}" PARENT_SCOPE)
+endfunction()

CMake/automate-vcpkg.cmake

@@ -0,0 +1,191 @@
+#------------------------------------------------------------------------------------------------------------
+#
+# Automate-VCPKG by Andre Taulien
+# ===============================
+#
+# Project Repository: https://github.com/REGoth-project/Automate-VCPKG
+# License ..........: MIT, see end of file.
+#
+# Based on: https://github.com/sutambe/cpptruths/blob/vcpkg_cmake_blog/cpp0x/vcpkg_test/CMakeLists.txt
+#
+# 
+# While [Vcpkg](https://github.com/microsoft/vcpkg) on it's own is awesome, it does add 
+# a little bit of complexity to getting a project to build. Even more if the one trying 
+# to compile your application is not too fond of the commandline. Additionally, CMake 
+# commands tend to get rather long with the toolchain path. 
+# 
+# To keep things simple for new users who just want to get the project to build, this 
+# script offers a solution.
+# 
+# Lets assume your main `CMakelists.txt` looks something like this:
+#
+#     cmake_minimum_required (VERSION 3.12.0)
+#     project (MyProject)
+#     
+#     add_executable(MyExecutable main.c)
+# 
+# To integrate Vcpkg into that `CMakelists.txt`, simple put the following lines before the 
+# call to `project(MyProject)`:
+# 
+#     include(cmake/automate-vcpkg.cmake)
+#     
+#     vcpkg_bootstrap()
+#     vcpkg_install_packages(libsquish physfs)
+# 
+# The call to `vcpkg_bootstrap()` will clone the official Vcpkg repository and bootstrap it. 
+# If it detected an existing environment variable defining a valid `VCPKG_ROOT`, it will 
+# update the existing installation of Vcpkg.
+# 
+# Arguments to `vcpkg_install_packages()` are the packages you want to install using Vcpkg.
+# 
+# If you want to keep the possibility for users to chose their own copy of Vcpkg, you can 
+# simply not run the code snippet mentioned above, something like this will work:
+# 
+#     option(SKIP_AUTOMATE_VCPKG "When ON, you will need to built the packages 
+#      required by MyProject on your own or supply your own vcpkg toolchain.")
+#     
+#     if (NOT SKIP_AUTOMATE_VCPKG)
+#       include(cmake/automate-vcpkg.cmake)
+#     
+#       vcpkg_bootstrap()
+#       vcpkg_install_packages(libsquish physfs)
+#     endif()
+#  
+# Then, the user has to supply the packages on their own, be it through Vcpkg or manually 
+# specifying their locations.
+#------------------------------------------------------------------------------------------------------------
+
+cmake_minimum_required (VERSION 3.12)
+
+if(WIN32)
+    set(VCPKG_FALLBACK_ROOT ${CMAKE_CURRENT_BINARY_DIR}/vcpkg CACHE STRING "vcpkg configuration directory to use if vcpkg was not installed on the system before")
+else()
+    set(VCPKG_FALLBACK_ROOT ${CMAKE_CURRENT_BINARY_DIR}/.vcpkg CACHE STRING  "vcpkg configuration directory to use if vcpkg was not installed on the system before")
+endif()
+
+# On Windows, Vcpkg defaults to x86, even on x64 systems. If we're 
+# doing a 64-bit build, we need to fix that.
+if (WIN32)
+
+    # Since the compiler checks haven't run yet, we need to figure
+    # out the value of CMAKE_SIZEOF_VOID_P ourselfs
+
+    include(CheckTypeSize)
+    enable_language(C)
+    check_type_size("void*" SIZEOF_VOID_P BUILTIN_TYPES_ONLY)
+    
+    if (SIZEOF_VOID_P EQUAL 8)
+        message(STATUS "Using Vcpkg triplet 'x64-windows'")
+        
+        set(VCPKG_TRIPLET x64-windows)
+    endif()
+endif()
+
+if(NOT DEFINED VCPKG_ROOT)
+    if(NOT DEFINED ENV{VCPKG_ROOT})
+	    set(VCPKG_ROOT ${VCPKG_FALLBACK_ROOT})
+    else()
+        set(VCPKG_ROOT $ENV{VCPKG_ROOT})
+    endif()
+endif()
+
+# Installs a new copy of Vcpkg or updates an existing one
+macro(vcpkg_bootstrap)
+    _install_or_update_vcpkg()
+
+    # Find out whether the user supplied their own VCPKG toolchain file
+    if(NOT DEFINED ${CMAKE_TOOLCHAIN_FILE})
+        # We know this wasn't set before so we need point the toolchain file to the newly found VCPKG_ROOT
+        set(CMAKE_TOOLCHAIN_FILE ${VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake CACHE STRING "")
+    
+        # Just setting vcpkg.cmake as toolchain file does not seem to actually pull in the code
+        include(${VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake)
+    
+        set(AUTOMATE_VCPKG_USE_SYSTEM_VCPKG OFF)
+    else()
+        # VCPKG_ROOT has been defined by the toolchain file already
+        set(AUTOMATE_VCPKG_USE_SYSTEM_VCPKG ON)
+    endif()
+    
+    message(STATUS "Automate VCPKG status:")
+    message(STATUS "  VCPKG_ROOT.....: ${VCPKG_ROOT}")
+    message(STATUS "  VCPKG_EXEC.....: ${VCPKG_EXEC}")
+    message(STATUS "  VCPKG_BOOTSTRAP: ${VCPKG_BOOTSTRAP}")
+endmacro()
+
+macro(_install_or_update_vcpkg)
+    if(NOT EXISTS ${VCPKG_ROOT})
+        message(STATUS "Cloning vcpkg in ${VCPKG_ROOT}")
+        execute_process(COMMAND git clone https://github.com/Microsoft/vcpkg.git ${VCPKG_ROOT} --depth 1)
+
+        # If a reproducible build is desired (and potentially old libraries are # ok), uncomment the
+        # following line and pin the vcpkg repository to a specific githash.
+        # execute_process(COMMAND git checkout 745a0aea597771a580d0b0f4886ea1e3a94dbca6 WORKING_DIRECTORY ${VCPKG_ROOT})
+    else()
+        # The following command has no effect if the vcpkg repository is in a detached head state.
+        message(STATUS "Auto-updating vcpkg in ${VCPKG_ROOT}")
+        execute_process(COMMAND git pull WORKING_DIRECTORY ${VCPKG_ROOT})
+    endif()
+
+    if(NOT EXISTS ${VCPKG_ROOT}/README.md)
+        message(FATAL_ERROR "***** FATAL ERROR: Could not clone vcpkg *****")
+    endif()
+
+    if(WIN32)
+        set(VCPKG_EXEC ${VCPKG_ROOT}/vcpkg.exe)
+        set(VCPKG_BOOTSTRAP ${VCPKG_ROOT}/bootstrap-vcpkg.bat)
+    else()
+        set(VCPKG_EXEC ${VCPKG_ROOT}/vcpkg)
+        set(VCPKG_BOOTSTRAP ${VCPKG_ROOT}/bootstrap-vcpkg.sh)
+    endif()
+
+    if(NOT EXISTS ${VCPKG_EXEC})
+        message("Bootstrapping vcpkg in ${VCPKG_ROOT}")
+        execute_process(COMMAND ${VCPKG_BOOTSTRAP} WORKING_DIRECTORY ${VCPKG_ROOT})
+    endif()
+
+    if(NOT EXISTS ${VCPKG_EXEC})
+        message(FATAL_ERROR "***** FATAL ERROR: Could not bootstrap vcpkg *****")
+    endif()
+   
+endmacro()
+
+# Installs the list of packages given as parameters using Vcpkg
+macro(vcpkg_install_packages)
+    
+    # Need the given list to be space-separated
+    #string (REPLACE ";" " " PACKAGES_LIST_STR "${ARGN}")
+
+    message(STATUS "Installing/Updating the following vcpkg-packages: ${PACKAGES_LIST_STR}")
+
+    if (VCPKG_TRIPLET)
+        set(ENV{VCPKG_DEFAULT_TRIPLET} "${VCPKG_TRIPLET}")
+    endif()
+
+    execute_process(
+        COMMAND ${VCPKG_EXEC} install ${ARGN}
+        WORKING_DIRECTORY ${VCPKG_ROOT}
+        )
+endmacro()
+    
+# MIT License
+# 
+# Copyright (c) 2019 REGoth-project
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.

CMakeLists.txt

@@ -0,0 +1,185 @@
+cmake_minimum_required(VERSION 3.16.0 FATAL_ERROR)
+
+set(CMAKE_SYSTEM_VERSION 10.0 CACHE STRING "" FORCE)
+set(CMAKE_CXX_STANDARD 20 CACHE STRING "The C++ standard to use")
+
+set(CMAKE_OSX_DEPLOYMENT_TARGET "10.15" CACHE STRING "Minimum OS X deployment version" FORCE)
+
+project(Ship VERSION 42.0.69 LANGUAGES C CXX)
+set(PROJECT_BUILD_NAME "GREG ALFA" CACHE STRING "")
+set(PROJECT_TEAM "github.com/harbourmasters" CACHE STRING "")
+
+set_property(DIRECTORY ${CMAKE_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT soh)
+add_compile_options($<$<CXX_COMPILER_ID:MSVC>:/MP>)
+
+if (CMAKE_SYSTEM_NAME MATCHES "Windows|Linux")
+    if(NOT DEFINED BUILD_CROWD_CONTROL)
+        set(BUILD_CROWD_CONTROL ON)
+    endif()
+endif()
+
+if (CMAKE_SYSTEM_NAME STREQUAL "Windows")
+include(CMake/automate-vcpkg.cmake)
+
+set(VCPKG_TRIPLET x64-windows-static)
+set(VCPKG_TARGET_TRIPLET x64-windows-static)
+
+vcpkg_bootstrap()
+vcpkg_install_packages(zlib bzip2 libpng SDL2 SDL2-net GLEW glfw3)
+endif()
+
+################################################################################
+# Set target arch type if empty. Visual studio solution generator provides it.
+################################################################################
+if (CMAKE_SYSTEM_NAME STREQUAL "Windows")
+    if(NOT CMAKE_VS_PLATFORM_NAME)
+        set(CMAKE_VS_PLATFORM_NAME "x64")
+    endif()
+    message("${CMAKE_VS_PLATFORM_NAME} architecture in use")
+
+    if(NOT ("${CMAKE_VS_PLATFORM_NAME}" STREQUAL "x64"
+        OR "${CMAKE_VS_PLATFORM_NAME}" STREQUAL "Win32"))
+        message(FATAL_ERROR "${CMAKE_VS_PLATFORM_NAME} arch is not supported!")
+    endif()
+endif()
+
+################################################################################
+# Global configuration types
+################################################################################
+if (CMAKE_SYSTEM_NAME STREQUAL "NintendoSwitch")
+set(CMAKE_C_FLAGS_DEBUG "-g -ffast-math -DDEBUG")
+set(CMAKE_CXX_FLAGS_DEBUG "-g -ffast-math -DDEBUG")
+set(CMAKE_C_FLAGS_RELEASE "-O3 -ffast-math -DNDEBUG")
+set(CMAKE_CXX_FLAGS_RELEASE "-O3 -ffast-math -DNDEBUG")
+else()
+set(CMAKE_C_FLAGS_RELEASE "-O2 -DNDEBUG")
+set(CMAKE_CXX_FLAGS_RELEASE "-O2 -DNDEBUG")
+set(CMAKE_OBJCXX_FLAGS_RELEASE "-O2 -DNDEBUG")
+endif()
+
+if(NOT CMAKE_BUILD_TYPE )
+    set(CMAKE_BUILD_TYPE "Debug" CACHE STRING "Choose the type of build." FORCE)
+endif()
+
+################################################################################
+# Common utils
+################################################################################
+include(CMake/Utils.cmake)
+
+if(CMAKE_SYSTEM_NAME MATCHES "Linux")
+    get_linux_lsb_release_information()
+    message(STATUS "Linux ${LSB_RELEASE_ID_SHORT} ${LSB_RELEASE_VERSION_SHORT} ${LSB_RELEASE_CODENAME_SHORT}")
+else()
+    message(STATUS ${CMAKE_SYSTEM_NAME})
+endif()
+
+################################################################################
+# Additional Global Settings(add specific info there)
+################################################################################
+include(CMake/GlobalSettingsInclude.cmake OPTIONAL)
+
+################################################################################
+# Use solution folders feature
+################################################################################
+set_property(GLOBAL PROPERTY USE_FOLDERS ON)
+
+################################################################################
+# Sub-projects
+################################################################################
+add_subdirectory(libultraship ${CMAKE_BINARY_DIR}/libultraship)
+add_subdirectory(ZAPDTR/ZAPD ${CMAKE_BINARY_DIR}/ZAPD)
+add_subdirectory(OTRExporter)
+add_subdirectory(soh)
+if(CMAKE_SYSTEM_NAME MATCHES "Windows|Linux")
+add_subdirectory(OTRGui)
+endif()
+
+set_property(TARGET soh PROPERTY APPIMAGE_DESKTOP_FILE_TERMINAL YES)
+set_property(TARGET soh PROPERTY APPIMAGE_DESKTOP_FILE "${CMAKE_SOURCE_DIR}/scripts/linux/appimage/soh.desktop")
+set_property(TARGET soh PROPERTY APPIMAGE_ICON_FILE "${CMAKE_BINARY_DIR}/sohIcon.png")
+
+if("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux")
+install(PROGRAMS "${CMAKE_SOURCE_DIR}/scripts/linux/appimage/soh.sh" DESTINATION . COMPONENT appimage)
+endif()
+
+find_package(Python3 COMPONENTS Interpreter)
+
+add_custom_target(
+    ExtractAssets
+    # CMake versions prior to 3.17 do not have the rm command, use remove instead for older versions
+    COMMAND ${CMAKE_COMMAND} -E $<IF:$<VERSION_LESS:${CMAKE_VERSION},3.17>,remove,rm> -f oot.otr oot-mq.otr
+    COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/OTRExporter/extract_assets.py -z "$<TARGET_FILE:ZAPD>" --non-interactive
+    COMMAND ${CMAKE_COMMAND} -DSOURCE_DIR=${CMAKE_CURRENT_SOURCE_DIR} -DBINARY_DIR=${CMAKE_BINARY_DIR} -P ${CMAKE_CURRENT_SOURCE_DIR}/copy-existing-otrs.cmake
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/OTRExporter
+    COMMENT "Running asset extraction..."
+    DEPENDS ZAPD
+    BYPRODUCTS oot.otr ${CMAKE_SOURCE_DIR}/oot.otr oot-mq.otr ${CMAKE_SOURCE_DIR}/oot-mq.otr
+)
+
+if(CMAKE_SYSTEM_NAME MATCHES "Linux")
+    find_package(ImageMagick COMPONENTS convert)
+    if (ImageMagick_FOUND)
+        execute_process (
+            COMMAND ${ImageMagick_convert_EXECUTABLE} soh/macosx/sohIcon.png -resize 512x512 ${CMAKE_BINARY_DIR}/sohIcon.png
+            OUTPUT_VARIABLE outVar
+        )
+    endif()
+endif()
+
+if(CMAKE_SYSTEM_NAME MATCHES "Darwin")
+add_custom_target(CreateOSXIcons
+    COMMAND mkdir -p ${CMAKE_BINARY_DIR}/macosx/soh.iconset
+    COMMAND sips -z 16 16     soh/macosx/sohIcon.png --out ${CMAKE_BINARY_DIR}/macosx/soh.iconset/icon_16x16.png
+    COMMAND sips -z 32 32     soh/macosx/sohIcon.png --out ${CMAKE_BINARY_DIR}/macosx/soh.iconset/icon_16x16@2x.png
+    COMMAND sips -z 32 32     soh/macosx/sohIcon.png --out ${CMAKE_BINARY_DIR}/macosx/soh.iconset/icon_32x32.png
+    COMMAND sips -z 64 64     soh/macosx/sohIcon.png --out ${CMAKE_BINARY_DIR}/macosx/soh.iconset/icon_32x32@2x.png
+    COMMAND sips -z 128 128   soh/macosx/sohIcon.png --out ${CMAKE_BINARY_DIR}/macosx/soh.iconset/icon_128x128.png
+    COMMAND sips -z 256 256   soh/macosx/sohIcon.png --out ${CMAKE_BINARY_DIR}/macosx/soh.iconset/icon_128x128@2x.png
+    COMMAND sips -z 256 256   soh/macosx/sohIcon.png --out ${CMAKE_BINARY_DIR}/macosx/soh.iconset/icon_256x256.png
+    COMMAND sips -z 512 512   soh/macosx/sohIcon.png --out ${CMAKE_BINARY_DIR}/macosx/soh.iconset/icon_256x256@2x.png
+    COMMAND sips -z 512 512   soh/macosx/sohIcon.png --out ${CMAKE_BINARY_DIR}/macosx/soh.iconset/icon_512x512.png
+    COMMAND cp                soh/macosx/sohIcon.png ${CMAKE_BINARY_DIR}/macosx/soh.iconset/icon_512x512@2x.png
+    COMMAND iconutil -c icns -o ${CMAKE_BINARY_DIR}/macosx/soh.icns ${CMAKE_BINARY_DIR}/macosx/soh.iconset
+    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+    COMMENT "Creating OSX icons ..."
+    )
+add_dependencies(soh CreateOSXIcons)
+
+add_custom_target(Assets ALL
+    COMMAND ${CMAKE_COMMAND} -Dsrc_dir="${CMAKE_SOURCE_DIR}/OTRGui/assets/extractor" -Ddst_dir="${CMAKE_BINARY_DIR}/assets/extractor" -P "${CMAKE_SOURCE_DIR}/OTRGui/Overwrite.cmake"
+    COMMAND ${CMAKE_COMMAND} -Dsrc_dir="${CMAKE_SOURCE_DIR}/OTRExporter/assets" -Ddst_dir="${CMAKE_BINARY_DIR}/assets/game" -P "${CMAKE_SOURCE_DIR}/OTRGui/Overwrite.cmake"
+    COMMAND ${CMAKE_COMMAND} -Dsrc_dir="${CMAKE_SOURCE_DIR}/soh/assets/xml" -Ddst_dir="${CMAKE_BINARY_DIR}/assets/extractor/xmls" -P "${CMAKE_SOURCE_DIR}/OTRGui/Overwrite.cmake"
+    )
+add_dependencies(soh Assets)
+
+install(TARGETS ZAPD DESTINATION ${CMAKE_BINARY_DIR}/assets/extractor)
+
+set(PROGRAM_PERMISSIONS_EXECUTE OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_EXECUTE GROUP_READ WORLD_EXECUTE WORLD_READ)
+
+install(DIRECTORY ${CMAKE_BINARY_DIR}/assets
+        DESTINATION .
+        PATTERN ZAPD.out
+        PERMISSIONS ${PROGRAM_PERMISSIONS_EXECUTE}
+        )
+
+install(CODE "
+    include(BundleUtilities)
+    fixup_bundle(\"\${CMAKE_INSTALL_PREFIX}/soh-macos\" \"\" \"${dirs}\")
+    ")
+
+endif()
+
+if(CMAKE_SYSTEM_NAME MATCHES "Windows|NintendoSwitch|CafeOS")
+install(FILES ${CMAKE_SOURCE_DIR}/README.md DESTINATION . COMPONENT ship RENAME readme.txt )
+endif()
+
+if(CMAKE_SYSTEM_NAME MATCHES "Linux")
+    set(CPACK_GENERATOR "External")
+elseif(CMAKE_SYSTEM_NAME MATCHES "Windows|NintendoSwitch|CafeOS")
+    set(CPACK_GENERATOR "ZIP")
+elseif(CMAKE_SYSTEM_NAME MATCHES "Darwin")
+    set(CPACK_GENERATOR "Bundle")
+endif()
+
+set(CPACK_PROJECT_CONFIG_FILE ${CMAKE_SOURCE_DIR}/CMake/Packaging-2.cmake)
+include(CMake/Packaging.cmake)

Dockerfile

@@ -0,0 +1,77 @@
+FROM ubuntu:20.04 as build
+
+ENV LANG C.UTF-8
+ARG DEBIAN_FRONTEND=noninteractive
+
+ENV GCCVER=10
+RUN apt-get update && \
+	apt-get upgrade -y && \
+	apt-get install -y \
+		binutils \
+		gcc-${GCCVER} \
+		g++-${GCCVER} \
+		patchelf \
+		p7zip-full \
+		python3 \
+		cmake \
+		make \
+		curl \
+		git \
+		lld \
+		libsdl2-dev \
+		zlib1g-dev \
+		libbz2-dev \
+		libpng-dev \
+		libgles2-mesa-dev \
+		wget \
+		gpg \
+		imagemagick \
+		ninja-build && \
+	apt-get install -y software-properties-common && \ 
+	wget -O - https://apt.kitware.com/keys/kitware-archive-latest.asc 2>/dev/null | gpg --dearmor - | tee /etc/apt/trusted.gpg.d/kitware.gpg >/dev/null && \
+	apt-add-repository "deb https://apt.kitware.com/ubuntu/ focal main" && \
+	apt-get update && \
+	apt-get upgrade -y && \
+	update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-${GCCVER} 10 && \
+	update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-${GCCVER} 10 
+	
+RUN git clone https://github.com/Perlmint/glew-cmake.git && \
+	cmake glew-cmake && \
+	make -j$(nproc) && \
+	make install
+
+ENV SDL2VER=2.0.22
+RUN curl -sLO https://libsdl.org/release/SDL2-${SDL2VER}.tar.gz && \
+	tar -xzf SDL2-${SDL2VER}.tar.gz && \
+	cd SDL2-${SDL2VER} && \
+	./configure --build=x86_64-linux-gnu && \
+	make -j$(nproc) && make install && \
+	rm ../SDL2-${SDL2VER}.tar.gz && \
+	cp -av /usr/local/lib/libSDL* /lib/x86_64-linux-gnu/
+
+ENV SDL2NETVER=2.2.0
+RUN curl -sLO https://www.libsdl.org/projects/SDL_net/release/SDL2_net-${SDL2NETVER}.tar.gz && \
+	tar -xzf SDL2_net-${SDL2NETVER}.tar.gz && \
+	cd SDL2_net-${SDL2NETVER} && \
+	./configure --build=x86_64-linux-gnu && \
+	make -j$(nproc) && make install && \
+	rm ../SDL2_net-${SDL2NETVER}.tar.gz && \
+	cp -av /usr/local/lib/libSDL* /lib/x86_64-linux-gnu/
+
+RUN \
+	ln -sf /proc/self/mounts /etc/mtab && \
+	mkdir -p /usr/local/share/keyring/ && \
+	wget -O /usr/local/share/keyring/devkitpro-pub.gpg https://apt.devkitpro.org/devkitpro-pub.gpg && \
+	echo "deb [signed-by=/usr/local/share/keyring/devkitpro-pub.gpg] https://apt.devkitpro.org stable main" > /etc/apt/sources.list.d/devkitpro.list && \
+	apt-get update -y && \
+	apt-get install -y devkitpro-pacman && \
+	yes | dkp-pacman -Syu switch-dev switch-portlibs wiiu-dev wiiu-portlibs --noconfirm
+
+ENV DEVKITPRO=/opt/devkitpro
+ENV DEVKITARM=/opt/devkitpro/devkitARM
+ENV DEVKITPPC=/opt/devkitpro/devkitPPC
+ENV PATH=$PATH:/opt/devkitpro/portlibs/switch/bin/:$DEVKITPPC/bin
+ENV WUT_ROOT=$DEVKITPRO/wut
+
+RUN mkdir /soh
+WORKDIR /soh

OTRExporter/.gitignore

@@ -341,10 +341,13 @@ build/
 ZAPDUtils/build/
 ZAPD/BuildInfo.h
 baserom/
+baserom_ntsc/
 *.vtx.inc
 *.otr
 *.swp
 *.a
+*.z64
+*.n64
 Extract/
 
 tmp.txt

OTRExporter/CFG/Config.xml

@@ -2,7 +2,7 @@
     <SymbolMap File="SymbolMap_OoTMqDbg.txt"/>
     <ActorList File="ActorList_OoTMqDbg.txt"/>
     <ObjectList File="ObjectList_OoTMqDbg.txt"/>
-    <ExternalXMLFolder Path="../soh/assets/xml/"/>
+    <ExternalXMLFolder Path="../soh/assets/xml/GC_NMQ_PAL_F/"/>
 	<TexturePool File="TexturePool.xml"/>
     <ExternalFile XmlPath="objects/gameplay_keep.xml" OutPath="objects/gameplay_keep/"/>
 </Root>

OTRExporter/CMake/Default.cmake

@@ -0,0 +1,65 @@
+################################################################################
+# Command for variable_watch. This command issues error message, if a variable
+# is changed. If variable PROPERTY_READER_GUARD_DISABLED is TRUE nothing happens
+#     variable_watch(<variable> property_reader_guard)
+################################################################################
+function(property_reader_guard VARIABLE ACCESS VALUE CURRENT_LIST_FILE STACK)
+    if("${PROPERTY_READER_GUARD_DISABLED}")
+        return()
+    endif()
+
+    if("${ACCESS}" STREQUAL "MODIFIED_ACCESS")
+        message(FATAL_ERROR
+            " Variable ${VARIABLE} is not supposed to be changed.\n"
+            " It is used only for reading target property ${VARIABLE}.\n"
+            " Use\n"
+            "     set_target_properties(\"<target>\" PROPERTIES \"${VARIABLE}\" \"<value>\")\n"
+            " or\n"
+            "     set_target_properties(\"<target>\" PROPERTIES \"${VARIABLE}_<CONFIG>\" \"<value>\")\n"
+            " instead.\n")
+    endif()
+endfunction()
+
+################################################################################
+# Create variable <name> with generator expression that expands to value of
+# target property <name>_<CONFIG>. If property is empty or not set then property
+# <name> is used instead. Variable <name> has watcher property_reader_guard that
+# doesn't allow to edit it.
+#     create_property_reader(<name>)
+# Input:
+#     name - Name of watched property and output variable
+################################################################################
+function(create_property_reader NAME)
+    set(PROPERTY_READER_GUARD_DISABLED TRUE)
+    set(CONFIG_VALUE "$<TARGET_GENEX_EVAL:${PROPS_TARGET},$<TARGET_PROPERTY:${PROPS_TARGET},${NAME}_$<UPPER_CASE:$<CONFIG>>>>")
+    set(IS_CONFIG_VALUE_EMPTY "$<STREQUAL:${CONFIG_VALUE},>")
+    set(GENERAL_VALUE "$<TARGET_GENEX_EVAL:${PROPS_TARGET},$<TARGET_PROPERTY:${PROPS_TARGET},${NAME}>>")
+    set("${NAME}" "$<IF:${IS_CONFIG_VALUE_EMPTY},${GENERAL_VALUE},${CONFIG_VALUE}>" PARENT_SCOPE)
+    variable_watch("${NAME}" property_reader_guard)
+endfunction()
+
+################################################################################
+# Set property $<name>_${PROPS_CONFIG_U} of ${PROPS_TARGET} to <value>
+#     set_config_specific_property(<name> <value>)
+# Input:
+#     name  - Prefix of property name
+#     value - New value
+################################################################################
+function(set_config_specific_property NAME VALUE)
+    set_target_properties("${PROPS_TARGET}" PROPERTIES "${NAME}_${PROPS_CONFIG_U}" "${VALUE}")
+endfunction()
+
+################################################################################
+
+create_property_reader("TARGET_NAME")
+create_property_reader("OUTPUT_DIRECTORY")
+
+set_config_specific_property("TARGET_NAME" "${PROPS_TARGET}")
+set_config_specific_property("OUTPUT_NAME" "${TARGET_NAME}")
+set_config_specific_property("ARCHIVE_OUTPUT_NAME" "${TARGET_NAME}")
+set_config_specific_property("LIBRARY_OUTPUT_NAME" "${TARGET_NAME}")
+set_config_specific_property("RUNTIME_OUTPUT_NAME" "${TARGET_NAME}")
+
+set_config_specific_property("ARCHIVE_OUTPUT_DIRECTORY" "${OUTPUT_DIRECTORY}")
+set_config_specific_property("LIBRARY_OUTPUT_DIRECTORY" "${OUTPUT_DIRECTORY}")
+set_config_specific_property("RUNTIME_OUTPUT_DIRECTORY" "${OUTPUT_DIRECTORY}")

OTRExporter/CMake/DefaultCXX.cmake

@@ -0,0 +1,12 @@
+include("${CMAKE_CURRENT_LIST_DIR}/Default.cmake")
+
+set_config_specific_property("OUTPUT_DIRECTORY" "${CMAKE_SOURCE_DIR}$<$<NOT:$<STREQUAL:${CMAKE_VS_PLATFORM_NAME},Win32>>:/${CMAKE_VS_PLATFORM_NAME}>/${PROPS_CONFIG}")
+
+if(MSVC)
+    create_property_reader("DEFAULT_CXX_EXCEPTION_HANDLING")
+    create_property_reader("DEFAULT_CXX_DEBUG_INFORMATION_FORMAT")
+
+    set_target_properties("${PROPS_TARGET}" PROPERTIES MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>DLL")
+    set_config_specific_property("DEFAULT_CXX_EXCEPTION_HANDLING" "/EHsc")
+    set_config_specific_property("DEFAULT_CXX_DEBUG_INFORMATION_FORMAT" "/Zi")
+endif()

OTRExporter/CMake/Utils.cmake

@@ -0,0 +1,233 @@
+# utils file for projects came from visual studio solution with cmake-converter.
+
+################################################################################
+# Wrap each token of the command with condition
+################################################################################
+cmake_policy(PUSH)
+cmake_policy(SET CMP0054 NEW)
+macro(prepare_commands)
+    unset(TOKEN_ROLE)
+    unset(COMMANDS)
+    foreach(TOKEN ${ARG_COMMANDS})
+        if("${TOKEN}" STREQUAL "COMMAND")
+            set(TOKEN_ROLE "KEYWORD")
+        elseif("${TOKEN_ROLE}" STREQUAL "KEYWORD")
+            set(TOKEN_ROLE "CONDITION")
+        elseif("${TOKEN_ROLE}" STREQUAL "CONDITION")
+            set(TOKEN_ROLE "COMMAND")
+        elseif("${TOKEN_ROLE}" STREQUAL "COMMAND")
+            set(TOKEN_ROLE "ARG")
+        endif()
+
+        if("${TOKEN_ROLE}" STREQUAL "KEYWORD")
+            list(APPEND COMMANDS "${TOKEN}")
+        elseif("${TOKEN_ROLE}" STREQUAL "CONDITION")
+            set(CONDITION ${TOKEN})
+        elseif("${TOKEN_ROLE}" STREQUAL "COMMAND")
+            list(APPEND COMMANDS "$<$<NOT:${CONDITION}>:${DUMMY}>$<${CONDITION}:${TOKEN}>")
+        elseif("${TOKEN_ROLE}" STREQUAL "ARG")
+            list(APPEND COMMANDS "$<${CONDITION}:${TOKEN}>")
+        endif()
+    endforeach()
+endmacro()
+cmake_policy(POP)
+
+################################################################################
+# Transform all the tokens to absolute paths
+################################################################################
+macro(prepare_output)
+    unset(OUTPUT)
+    foreach(TOKEN ${ARG_OUTPUT})
+        if(IS_ABSOLUTE ${TOKEN})
+            list(APPEND OUTPUT "${TOKEN}")
+        else()
+            list(APPEND OUTPUT "${CMAKE_CURRENT_SOURCE_DIR}/${TOKEN}")
+        endif()
+    endforeach()
+endmacro()
+
+################################################################################
+# Parse add_custom_command_if args.
+#
+# Input:
+#     PRE_BUILD  - Pre build event option
+#     PRE_LINK   - Pre link event option
+#     POST_BUILD - Post build event option
+#     TARGET     - Target
+#     OUTPUT     - List of output files
+#     DEPENDS    - List of files on which the command depends
+#     COMMANDS   - List of commands(COMMAND condition1 commannd1 args1 COMMAND
+#                  condition2 commannd2 args2 ...)
+# Output:
+#     OUTPUT     - Output files
+#     DEPENDS    - Files on which the command depends
+#     COMMENT    - Comment
+#     PRE_BUILD  - TRUE/FALSE
+#     PRE_LINK   - TRUE/FALSE
+#     POST_BUILD - TRUE/FALSE
+#     TARGET     - Target name
+#     COMMANDS   - Prepared commands(every token is wrapped in CONDITION)
+#     NAME       - Unique name for custom target
+#     STEP       - PRE_BUILD/PRE_LINK/POST_BUILD
+################################################################################
+function(add_custom_command_if_parse_arguments)
+    cmake_parse_arguments("ARG" "PRE_BUILD;PRE_LINK;POST_BUILD" "TARGET;COMMENT" "DEPENDS;OUTPUT;COMMANDS" ${ARGN})
+
+    if(WIN32)
+        set(DUMMY "cd.")
+    elseif(UNIX)
+        set(DUMMY "true")
+    endif()
+
+    prepare_commands()
+    prepare_output()
+
+    set(DEPENDS "${ARG_DEPENDS}")
+    set(COMMENT "${ARG_COMMENT}")
+    set(PRE_BUILD "${ARG_PRE_BUILD}")
+    set(PRE_LINK "${ARG_PRE_LINK}")
+    set(POST_BUILD "${ARG_POST_BUILD}")
+    set(TARGET "${ARG_TARGET}")
+    if(PRE_BUILD)
+        set(STEP "PRE_BUILD")
+    elseif(PRE_LINK)
+        set(STEP "PRE_LINK")
+    elseif(POST_BUILD)
+        set(STEP "POST_BUILD")
+    endif()
+    set(NAME "${TARGET}_${STEP}")
+
+    set(OUTPUT "${OUTPUT}" PARENT_SCOPE)
+    set(DEPENDS "${DEPENDS}" PARENT_SCOPE)
+    set(COMMENT "${COMMENT}" PARENT_SCOPE)
+    set(PRE_BUILD "${PRE_BUILD}" PARENT_SCOPE)
+    set(PRE_LINK "${PRE_LINK}" PARENT_SCOPE)
+    set(POST_BUILD "${POST_BUILD}" PARENT_SCOPE)
+    set(TARGET "${TARGET}" PARENT_SCOPE)
+    set(COMMANDS "${COMMANDS}" PARENT_SCOPE)
+    set(STEP "${STEP}" PARENT_SCOPE)
+    set(NAME "${NAME}" PARENT_SCOPE)
+endfunction()
+
+################################################################################
+# Add conditional custom command
+#
+# Generating Files
+# The first signature is for adding a custom command to produce an output:
+#     add_custom_command_if(
+#         <OUTPUT output1 [output2 ...]>
+#         <COMMANDS>
+#         <COMMAND condition command1 [args1...]>
+#         [COMMAND condition command2 [args2...]]
+#         [DEPENDS [depends...]]
+#         [COMMENT comment]
+#
+# Build Events
+#     add_custom_command_if(
+#         <TARGET target>
+#         <PRE_BUILD | PRE_LINK | POST_BUILD>
+#         <COMMAND condition command1 [args1...]>
+#         [COMMAND condition command2 [args2...]]
+#         [COMMENT comment]
+#
+# Input:
+#     output     - Output files the command is expected to produce
+#     condition  - Generator expression for wrapping the command
+#     command    - Command-line(s) to execute at build time.
+#     args       - Command`s args
+#     depends    - Files on which the command depends
+#     comment    - Display the given message before the commands are executed at
+#                  build time.
+#     PRE_BUILD  - Run before any other rules are executed within the target
+#     PRE_LINK   - Run after sources have been compiled but before linking the
+#                  binary
+#     POST_BUILD - Run after all other rules within the target have been
+#                  executed
+################################################################################
+function(add_custom_command_if)
+    add_custom_command_if_parse_arguments(${ARGN})
+
+    if(OUTPUT AND TARGET)
+        message(FATAL_ERROR  "Wrong syntax. A TARGET and OUTPUT can not both be specified.")
+    endif()
+
+    if(OUTPUT)
+        add_custom_command(OUTPUT ${OUTPUT}
+                           ${COMMANDS}
+                           DEPENDS ${DEPENDS}
+                           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+                           COMMENT ${COMMENT})
+    elseif(TARGET)
+        if(PRE_BUILD AND NOT ${CMAKE_GENERATOR} MATCHES "Visual Studio")
+            add_custom_target(
+                ${NAME}
+                ${COMMANDS}
+                WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+                COMMENT ${COMMENT})
+            add_dependencies(${TARGET} ${NAME})
+        else()
+            add_custom_command(
+                TARGET ${TARGET}
+                ${STEP}
+                ${COMMANDS}
+                WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+                COMMENT ${COMMENT})
+        endif()
+    else()
+        message(FATAL_ERROR "Wrong syntax. A TARGET or OUTPUT must be specified.")
+    endif()
+endfunction()
+
+################################################################################
+# Use props file for a target and configs
+#     use_props(<target> <configs...> <props_file>)
+# Inside <props_file> there are following variables:
+#     PROPS_TARGET   - <target>
+#     PROPS_CONFIG   - One of <configs...>
+#     PROPS_CONFIG_U - Uppercase PROPS_CONFIG
+# Input:
+#     target      - Target to apply props file
+#     configs     - Build configurations to apply props file
+#     props_file  - CMake script
+################################################################################
+macro(use_props TARGET CONFIGS PROPS_FILE)
+    set(PROPS_TARGET "${TARGET}")
+    foreach(PROPS_CONFIG ${CONFIGS})
+        string(TOUPPER "${PROPS_CONFIG}" PROPS_CONFIG_U)
+
+        get_filename_component(ABSOLUTE_PROPS_FILE "${PROPS_FILE}" ABSOLUTE BASE_DIR "${CMAKE_CURRENT_LIST_DIR}")
+        if(EXISTS "${ABSOLUTE_PROPS_FILE}")
+            include("${ABSOLUTE_PROPS_FILE}")
+        else()
+            message(WARNING "Corresponding cmake file from props \"${ABSOLUTE_PROPS_FILE}\" doesn't exist")
+        endif()
+    endforeach()
+endmacro()
+
+################################################################################
+# Add compile options to source file
+#     source_file_compile_options(<source_file> [compile_options...])
+# Input:
+#     source_file     - Source file
+#     compile_options - Options to add to COMPILE_FLAGS property
+################################################################################
+function(source_file_compile_options SOURCE_FILE)
+    if("${ARGC}" LESS_EQUAL "1")
+        return()
+    endif()
+
+    get_source_file_property(COMPILE_OPTIONS "${SOURCE_FILE}" COMPILE_OPTIONS)
+
+    if(COMPILE_OPTIONS)
+        list(APPEND COMPILE_OPTIONS ${ARGN})
+    else()
+        set(COMPILE_OPTIONS "${ARGN}")
+    endif()
+
+    set_source_files_properties("${SOURCE_FILE}" PROPERTIES COMPILE_OPTIONS "${COMPILE_OPTIONS}")
+endfunction()
+
+################################################################################
+# Default properties of visual studio projects
+################################################################################
+set(DEFAULT_CXX_PROPS "${CMAKE_CURRENT_LIST_DIR}/DefaultCXX.cmake")

OTRExporter/CMakeLists.txt

@@ -0,0 +1,96 @@
+cmake_minimum_required(VERSION 3.16.0 FATAL_ERROR)
+
+set(CMAKE_SYSTEM_VERSION 10.0 CACHE STRING "" FORCE)
+set(CMAKE_CXX_STANDARD 20 CACHE STRING "The C++ standard to use")
+#set(CMAKE_C_STANDARD 11 CACHE STRING "The C standard to use")
+set(CMAKE_C_STANDARD 11)
+
+project(OTRExporter C CXX)
+
+################################################################################
+# Set target arch type if empty. Visual studio solution generator provides it.
+################################################################################
+if (CMAKE_SYSTEM_NAME STREQUAL "Windows")
+	if(NOT CMAKE_VS_PLATFORM_NAME)
+		set(CMAKE_VS_PLATFORM_NAME "x64")
+	endif()
+	message("${CMAKE_VS_PLATFORM_NAME} architecture in use")
+
+	if(NOT ("${CMAKE_VS_PLATFORM_NAME}" STREQUAL "x64"
+		OR "${CMAKE_VS_PLATFORM_NAME}" STREQUAL "Win32"))
+		message(FATAL_ERROR "${CMAKE_VS_PLATFORM_NAME} arch is not supported!")
+	endif()
+endif()
+
+################################################################################
+# Global configuration types
+################################################################################
+set(CMAKE_CONFIGURATION_TYPES
+    "Debug"
+    "Release"
+    CACHE STRING "" FORCE
+)
+
+################################################################################
+# Global compiler options
+################################################################################
+if(MSVC)
+    # remove default flags provided with CMake for MSVC
+    set(CMAKE_C_FLAGS "")
+    set(CMAKE_C_FLAGS_DEBUG "")
+    set(CMAKE_C_FLAGS_RELEASE "")
+    set(CMAKE_CXX_FLAGS "")
+    set(CMAKE_CXX_FLAGS_DEBUG "")
+    set(CMAKE_CXX_FLAGS_RELEASE "")
+endif()
+
+################################################################################
+# Global linker options
+################################################################################
+if(MSVC)
+    # remove default flags provided with CMake for MSVC
+    set(CMAKE_EXE_LINKER_FLAGS "")
+    set(CMAKE_MODULE_LINKER_FLAGS "")
+    set(CMAKE_SHARED_LINKER_FLAGS "")
+    set(CMAKE_STATIC_LINKER_FLAGS "")
+    set(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS}")
+    set(CMAKE_MODULE_LINKER_FLAGS_DEBUG "${CMAKE_MODULE_LINKER_FLAGS}")
+    set(CMAKE_SHARED_LINKER_FLAGS_DEBUG "${CMAKE_SHARED_LINKER_FLAGS}")
+    set(CMAKE_STATIC_LINKER_FLAGS_DEBUG "${CMAKE_STATIC_LINKER_FLAGS}")
+    set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS}")
+    set(CMAKE_MODULE_LINKER_FLAGS_RELEASE "${CMAKE_MODULE_LINKER_FLAGS}")
+    set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS}")
+    set(CMAKE_STATIC_LINKER_FLAGS_RELEASE "${CMAKE_STATIC_LINKER_FLAGS}")
+endif()
+
+################################################################################
+# Common utils
+################################################################################
+include(CMake/Utils.cmake)
+
+################################################################################
+# Additional Global Settings(add specific info there)
+################################################################################
+include(CMake/GlobalSettingsInclude.cmake OPTIONAL)
+
+################################################################################
+# Use solution folders feature
+################################################################################
+set_property(GLOBAL PROPERTY USE_FOLDERS ON)
+
+################################################################################
+# Sub-projects
+################################################################################
+if (NOT TARGET libultraship)
+    add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/../libultraship ${CMAKE_BINARY_DIR}/libultraship)
+endif()
+
+if (NOT TARGET ZAPD)
+    add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/../ZAPDTR/ZAPD ${CMAKE_BINARY_DIR}/ZAPD)
+endif()
+
+if (NOT TARGET ZAPDUtils)
+    add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/../libultraship/extern/ZAPDUtils ${CMAKE_BINARY_DIR}/ZAPDUtils)
+endif()
+
+add_subdirectory(OTRExporter)

OTRExporter/OTRExporter.sln

@@ -1,68 +0,0 @@
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 16
-VisualStudioVersion = 16.0.30320.27
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "OTRExporter", "OTRExporter\OTRExporter.vcxproj", "{A6103FD3-0709-4FC7-B066-1A6E056D6306}"
-	ProjectSection(ProjectDependencies) = postProject
-		{6DA9B521-65B7-41E2-8F8A-F0451CC18ED8} = {6DA9B521-65B7-41E2-8F8A-F0451CC18ED8}
-	EndProjectSection
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libultraship", "..\libultraship\libultraship\libultraship.vcxproj", "{6DA9B521-65B7-41E2-8F8A-F0451CC18ED8}"
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ZAPD", "..\ZAPDTR\ZAPD\ZAPD.vcxproj", "{B53F9E5B-0A58-4BAE-9AFE-856C8CBB8D36}"
-	ProjectSection(ProjectDependencies) = postProject
-		{6DA9B521-65B7-41E2-8F8A-F0451CC18ED8} = {6DA9B521-65B7-41E2-8F8A-F0451CC18ED8}
-		{A2E01C3E-D647-45D1-9788-043DEBC1A908} = {A2E01C3E-D647-45D1-9788-043DEBC1A908}
-		{A6103FD3-0709-4FC7-B066-1A6E056D6306} = {A6103FD3-0709-4FC7-B066-1A6E056D6306}
-	EndProjectSection
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ZAPDUtils", "..\ZAPDTR\ZAPDUtils\ZAPDUtils.vcxproj", "{A2E01C3E-D647-45D1-9788-043DEBC1A908}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|x64 = Debug|x64
-		Debug|x86 = Debug|x86
-		Release|x64 = Release|x64
-		Release|x86 = Release|x86
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{A6103FD3-0709-4FC7-B066-1A6E056D6306}.Debug|x64.ActiveCfg = Debug|x64
-		{A6103FD3-0709-4FC7-B066-1A6E056D6306}.Debug|x64.Build.0 = Debug|x64
-		{A6103FD3-0709-4FC7-B066-1A6E056D6306}.Debug|x86.ActiveCfg = Debug|Win32
-		{A6103FD3-0709-4FC7-B066-1A6E056D6306}.Debug|x86.Build.0 = Debug|Win32
-		{A6103FD3-0709-4FC7-B066-1A6E056D6306}.Release|x64.ActiveCfg = Release|x64
-		{A6103FD3-0709-4FC7-B066-1A6E056D6306}.Release|x64.Build.0 = Release|x64
-		{A6103FD3-0709-4FC7-B066-1A6E056D6306}.Release|x86.ActiveCfg = Release|Win32
-		{A6103FD3-0709-4FC7-B066-1A6E056D6306}.Release|x86.Build.0 = Release|Win32
-		{6DA9B521-65B7-41E2-8F8A-F0451CC18ED8}.Debug|x64.ActiveCfg = Debug|x64
-		{6DA9B521-65B7-41E2-8F8A-F0451CC18ED8}.Debug|x64.Build.0 = Debug|x64
-		{6DA9B521-65B7-41E2-8F8A-F0451CC18ED8}.Debug|x86.ActiveCfg = Debug|Win32
-		{6DA9B521-65B7-41E2-8F8A-F0451CC18ED8}.Debug|x86.Build.0 = Debug|Win32
-		{6DA9B521-65B7-41E2-8F8A-F0451CC18ED8}.Release|x64.ActiveCfg = Release|x64
-		{6DA9B521-65B7-41E2-8F8A-F0451CC18ED8}.Release|x64.Build.0 = Release|x64
-		{6DA9B521-65B7-41E2-8F8A-F0451CC18ED8}.Release|x86.ActiveCfg = Release|Win32
-		{6DA9B521-65B7-41E2-8F8A-F0451CC18ED8}.Release|x86.Build.0 = Release|Win32
-		{B53F9E5B-0A58-4BAE-9AFE-856C8CBB8D36}.Debug|x64.ActiveCfg = Debug|x64
-		{B53F9E5B-0A58-4BAE-9AFE-856C8CBB8D36}.Debug|x64.Build.0 = Debug|x64
-		{B53F9E5B-0A58-4BAE-9AFE-856C8CBB8D36}.Debug|x86.ActiveCfg = Debug|Win32
-		{B53F9E5B-0A58-4BAE-9AFE-856C8CBB8D36}.Debug|x86.Build.0 = Debug|Win32
-		{B53F9E5B-0A58-4BAE-9AFE-856C8CBB8D36}.Release|x64.ActiveCfg = Release|x64
-		{B53F9E5B-0A58-4BAE-9AFE-856C8CBB8D36}.Release|x64.Build.0 = Release|x64
-		{B53F9E5B-0A58-4BAE-9AFE-856C8CBB8D36}.Release|x86.ActiveCfg = Release|Win32
-		{B53F9E5B-0A58-4BAE-9AFE-856C8CBB8D36}.Release|x86.Build.0 = Release|Win32
-		{A2E01C3E-D647-45D1-9788-043DEBC1A908}.Debug|x64.ActiveCfg = Debug|x64
-		{A2E01C3E-D647-45D1-9788-043DEBC1A908}.Debug|x64.Build.0 = Debug|x64
-		{A2E01C3E-D647-45D1-9788-043DEBC1A908}.Debug|x86.ActiveCfg = Debug|Win32
-		{A2E01C3E-D647-45D1-9788-043DEBC1A908}.Debug|x86.Build.0 = Debug|Win32
-		{A2E01C3E-D647-45D1-9788-043DEBC1A908}.Release|x64.ActiveCfg = Release|x64
-		{A2E01C3E-D647-45D1-9788-043DEBC1A908}.Release|x64.Build.0 = Release|x64
-		{A2E01C3E-D647-45D1-9788-043DEBC1A908}.Release|x86.ActiveCfg = Release|Win32
-		{A2E01C3E-D647-45D1-9788-043DEBC1A908}.Release|x86.Build.0 = Release|Win32
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-	GlobalSection(ExtensibilityGlobals) = postSolution
-		SolutionGuid = {DCE19FF1-37C0-49CD-915A-DD695E15F00B}
-	EndGlobalSection
-EndGlobal

OTRExporter/OTRExporter/AnimationExporter.cpp

@@ -1,11 +1,11 @@
 #include "AnimationExporter.h"
-#include <Animation.h>
+#include <resource/type/Animation.h>
 
 void OTRExporter_Animation::Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer)
 {
 	ZAnimation* anim = (ZAnimation*)res;
 
-	WriteHeader(res, outPath, writer, Ship::ResourceType::Animation);
+	WriteHeader(res, outPath, writer, Ship::ResourceType::SOH_Animation);
 
 	ZNormalAnimation* normalAnim = dynamic_cast<ZNormalAnimation*>(anim);
 	ZCurveAnimation* curveAnim = dynamic_cast<ZCurveAnimation*>(anim);
@@ -49,12 +49,12 @@ void OTRExporter_Animation::Save(ZResource* res, const fs::path& outPath, Binary
 
 		writer->Write((uint32_t)normalAnim->rotationValues.size());
 
-		for (int i = 0; i < normalAnim->rotationValues.size(); i++)
+		for (size_t i = 0; i < normalAnim->rotationValues.size(); i++)
 			writer->Write(normalAnim->rotationValues[i]);
 
 		writer->Write((uint32_t)normalAnim->rotationIndices.size());
 
-		for (int i = 0; i < normalAnim->rotationIndices.size(); i++)
+		for (size_t i = 0; i < normalAnim->rotationIndices.size(); i++)
 		{
 			writer->Write(normalAnim->rotationIndices[i].x);
 			writer->Write(normalAnim->rotationIndices[i].y);

OTRExporter/OTRExporter/ArrayExporter.cpp

@@ -10,7 +10,7 @@ void OTRExporter_Array::Save(ZResource* res, const fs::path& outPath, BinaryWrit
 	writer->Write((uint32_t)arr->resList[0]->GetResourceType());
 	writer->Write((uint32_t)arr->arrayCnt);
 
-	for (int i = 0; i < arr->arrayCnt; i++)
+	for (size_t i = 0; i < arr->arrayCnt; i++)
 	{
 		if (arr->resList[i]->GetResourceType() == ZResourceType::Vertex)
 		{
@@ -32,7 +32,7 @@ void OTRExporter_Array::Save(ZResource* res, const fs::path& outPath, BinaryWrit
 			writer->Write((uint32_t)vec->scalarType);
 			writer->Write((uint32_t)vec->dimensions);
 
-			for (int k = 0; k < vec->dimensions; k++)
+			for (size_t k = 0; k < vec->dimensions; k++)
 			{
 				// OTRTODO: Duplicate code here. Cleanup at a later date...
 				switch (vec->scalarType)
@@ -62,6 +62,8 @@ void OTRExporter_Array::Save(ZResource* res, const fs::path& outPath, BinaryWrit
 					writer->Write(vec->scalars[k].scalarData.u64);
 					break;
 					// OTRTODO: ADD OTHER TYPES
+				default:
+					break;
 				}
 			}
 		}
@@ -98,6 +100,8 @@ void OTRExporter_Array::Save(ZResource* res, const fs::path& outPath, BinaryWrit
 				writer->Write(scal->scalarData.u64);
 				break;
 				// OTRTODO: ADD OTHER TYPES
+			default:
+				break;
 			}
 		}
 	}

OTRExporter/OTRExporter/AudioExporter.cpp

@@ -0,0 +1,191 @@
+#include "AudioExporter.h"
+#include "Main.h"
+#include <Utils/MemoryStream.h>
+#include <Globals.h>
+#include <Utils/File.h>
+#include "DisplayListExporter.h"
+
+void OTRExporter_Audio::WriteSampleEntryReference(ZAudio* audio, SampleEntry* entry, std::map<uint32_t, SampleEntry*> samples, BinaryWriter* writer)
+{
+	writer->Write((uint8_t)(entry != nullptr ? 1 : 0));
+
+	if (entry != nullptr)
+	{
+		if (audio->sampleOffsets[entry->bankId].find(entry->sampleLoopOffset) != audio->sampleOffsets[entry->bankId].end())
+		{
+			if (audio->sampleOffsets[entry->bankId][entry->sampleLoopOffset].find(entry->sampleDataOffset) != audio->sampleOffsets[entry->bankId][entry->sampleLoopOffset].end())
+			{
+				writer->Write(StringHelper::Sprintf("audio/samples/%s", audio->sampleOffsets[entry->bankId][entry->sampleLoopOffset][entry->sampleDataOffset].c_str()));
+			}
+			else
+				writer->Write(entry->fileName);
+		}
+		else
+			writer->Write(entry->fileName);
+	}
+	else
+		writer->Write("");
+}
+
+void OTRExporter_Audio::WriteSampleEntry(SampleEntry* entry, BinaryWriter* writer)
+{
+	WriteHeader(nullptr, "", writer, Ship::ResourceType::SOH_AudioSample, Ship::Version::Rachael);
+
+	writer->Write(entry->codec);
+	writer->Write(entry->medium);
+	writer->Write(entry->unk_bit26);
+	writer->Write(entry->unk_bit25);
+
+	writer->Write((uint32_t)entry->data.size());
+	writer->Write((char*)entry->data.data(), entry->data.size());
+
+	writer->Write((uint32_t)(entry->loop.start));
+	writer->Write((uint32_t)(entry->loop.end));
+	writer->Write((uint32_t)(entry->loop.count));
+	writer->Write((uint32_t)entry->loop.states.size());
+
+	for (size_t i = 0; i < entry->loop.states.size(); i++)
+		writer->Write((entry->loop.states[i]));
+
+	writer->Write((uint32_t)(entry->book.order));
+	writer->Write((uint32_t)(entry->book.npredictors));
+	writer->Write((uint32_t)entry->book.books.size());
+
+	for (size_t i = 0; i < entry->book.books.size(); i++)
+		writer->Write((entry->book.books[i]));
+}
+
+void OTRExporter_Audio::WriteSoundFontEntry(ZAudio* audio, SoundFontEntry* entry, std::map<uint32_t, SampleEntry*> samples, BinaryWriter* writer)
+{
+	writer->Write((uint8_t)(entry != nullptr ? 1 : 0));
+
+	if (entry != nullptr)
+	{
+		WriteSampleEntryReference(audio, entry->sampleEntry, samples, writer);
+		writer->Write(entry->tuning);
+	}
+}
+
+void OTRExporter_Audio::WriteEnvData(std::vector<AdsrEnvelope*> envelopes, BinaryWriter* writer)
+{
+	writer->Write((uint32_t)envelopes.size());
+
+	for (auto env : envelopes)
+	{
+		writer->Write(env->delay);
+		writer->Write(env->arg);
+	}
+}
+
+void OTRExporter_Audio::Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer)
+{
+	ZAudio* audio = (ZAudio*)res;
+
+	WriteHeader(res, outPath, writer, Ship::ResourceType::SOH_Audio, Ship::Version::Rachael);
+
+	// Write Samples as individual files
+	for (auto pair : audio->samples)
+	{
+		MemoryStream* sampleStream = new MemoryStream();
+		BinaryWriter sampleWriter = BinaryWriter(sampleStream);
+
+		writer->Write((uint32_t)pair.first);
+		WriteSampleEntry(pair.second, &sampleWriter);
+
+		std::string basePath = "";
+
+		if (audio->sampleOffsets[pair.second->bankId].find(pair.second->sampleLoopOffset) != audio->sampleOffsets[pair.second->bankId].end())
+		{
+			if (audio->sampleOffsets[pair.second->bankId][pair.second->sampleLoopOffset].find(pair.second->sampleDataOffset) != audio->sampleOffsets[pair.second->bankId][pair.second->sampleLoopOffset].end())
+				basePath = StringHelper::Sprintf("samples/%s", audio->sampleOffsets[pair.second->bankId][pair.second->sampleLoopOffset][pair.second->sampleDataOffset].c_str());
+			else
+				basePath = StringHelper::Sprintf("samples/sample_%08X", pair.first);
+		}
+		else
+			basePath = StringHelper::Sprintf("samples/sample_%08X", pair.first);
+
+		std::string fName = OTRExporter_DisplayList::GetPathToRes(res, basePath);
+		AddFile(fName, sampleStream->ToVector());
+	}
+
+	// Write the soundfont table
+	for (size_t i = 0; i < audio->soundFontTable.size(); i++)
+	{
+		MemoryStream* fntStream = new MemoryStream();
+		BinaryWriter fntWriter = BinaryWriter(fntStream);
+
+		WriteHeader(nullptr, "", &fntWriter, Ship::ResourceType::SOH_AudioSoundFont, Ship::Version::Rachael);
+
+		fntWriter.Write((uint32_t)i);
+		fntWriter.Write(audio->soundFontTable[i].medium);
+		fntWriter.Write(audio->soundFontTable[i].cachePolicy);
+		fntWriter.Write(audio->soundFontTable[i].data1);
+		fntWriter.Write(audio->soundFontTable[i].data2);
+		fntWriter.Write(audio->soundFontTable[i].data3);
+
+		fntWriter.Write((uint32_t)audio->soundFontTable[i].drums.size());
+		fntWriter.Write((uint32_t)audio->soundFontTable[i].instruments.size());
+		fntWriter.Write((uint32_t)audio->soundFontTable[i].soundEffects.size());
+
+		for (size_t k = 0; k < audio->soundFontTable[i].drums.size(); k++)
+		{
+			fntWriter.Write(audio->soundFontTable[i].drums[k].releaseRate);
+			fntWriter.Write(audio->soundFontTable[i].drums[k].pan);
+			fntWriter.Write(audio->soundFontTable[i].drums[k].loaded);
+
+			WriteEnvData(audio->soundFontTable[i].drums[k].env, &fntWriter);
+
+			WriteSampleEntryReference(audio, audio->soundFontTable[i].drums[k].sample, audio->samples, &fntWriter);
+			fntWriter.Write(audio->soundFontTable[i].drums[k].tuning);
+		}
+
+		for (size_t k = 0; k < audio->soundFontTable[i].instruments.size(); k++)
+		{
+			fntWriter.Write((uint8_t)audio->soundFontTable[i].instruments[k].isValidInstrument);
+
+			fntWriter.Write(audio->soundFontTable[i].instruments[k].loaded);
+			fntWriter.Write(audio->soundFontTable[i].instruments[k].normalRangeLo);
+			fntWriter.Write(audio->soundFontTable[i].instruments[k].normalRangeHi);
+			fntWriter.Write(audio->soundFontTable[i].instruments[k].releaseRate);
+
+			WriteEnvData(audio->soundFontTable[i].instruments[k].env, &fntWriter);
+
+			WriteSoundFontEntry(audio, audio->soundFontTable[i].instruments[k].lowNotesSound, audio->samples, &fntWriter);
+			WriteSoundFontEntry(audio, audio->soundFontTable[i].instruments[k].normalNotesSound, audio->samples, &fntWriter);
+			WriteSoundFontEntry(audio, audio->soundFontTable[i].instruments[k].highNotesSound, audio->samples, &fntWriter);
+		}
+
+		for (size_t k = 0; k < audio->soundFontTable[i].soundEffects.size(); k++)
+		{
+			WriteSoundFontEntry(audio, audio->soundFontTable[i].soundEffects[k], audio->samples, &fntWriter);
+		}
+
+		//std::string fName = OTRExporter_DisplayList::GetPathToRes(res, StringHelper::Sprintf("fonts/font_%02X", i));
+		std::string fName = OTRExporter_DisplayList::GetPathToRes(res, StringHelper::Sprintf("fonts/%s", audio->soundFontNames[i].c_str()));
+		AddFile(fName, fntStream->ToVector());
+	}
+
+	// Write Sequences
+	for (size_t i = 0; i < audio->sequences.size(); i++)
+	{
+		auto seq = audio->sequences[i];
+
+		MemoryStream* seqStream = new MemoryStream();
+		BinaryWriter seqWriter = BinaryWriter(seqStream);
+
+		WriteHeader(nullptr, "", &seqWriter, Ship::ResourceType::SOH_AudioSequence, Ship::Version::Rachael);
+
+		seqWriter.Write((uint32_t)seq.size());
+		seqWriter.Write(seq.data(), seq.size());
+		seqWriter.Write((uint8_t)i);
+		seqWriter.Write((uint8_t)audio->sequenceTable[i].medium);
+		seqWriter.Write((uint8_t)audio->sequenceTable[i].cachePolicy);
+		seqWriter.Write((uint32_t)audio->fontIndices[i].size());
+
+		for (size_t k = 0; k < audio->fontIndices[i].size(); k++)
+			seqWriter.Write((uint8_t)audio->fontIndices[i][k]);
+
+		std::string fName = OTRExporter_DisplayList::GetPathToRes(res, StringHelper::Sprintf("sequences/%s", audio->seqNames[i].c_str()));
+		AddFile(fName, seqStream->ToVector());
+	}
+}

OTRExporter/OTRExporter/AudioExporter.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "ZResource.h"
+#include "ZAudio.h"
+#include "Exporter.h"
+#include <Utils/BinaryWriter.h>
+
+class OTRExporter_Audio : public OTRExporter
+{
+public:
+	void WriteSampleEntry(SampleEntry* entry, BinaryWriter* writer);
+	void WriteSampleEntryReference(ZAudio* audio, SampleEntry* entry, std::map<uint32_t, SampleEntry*> samples, BinaryWriter* writer);
+	void WriteSoundFontEntry(ZAudio* audio, SoundFontEntry* entry, std::map<uint32_t, SampleEntry*> samples, BinaryWriter* writer);
+	void WriteEnvData(std::vector<AdsrEnvelope*> envelopes, BinaryWriter* writer);
+	virtual void Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer) override;
+};

OTRExporter/OTRExporter/BackgroundExporter.cpp

@@ -4,6 +4,10 @@
 void OTRExporter_Background::Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer)
 {
 	ZBackground* bg = (ZBackground*)res;
+
+	WriteHeader(bg, outPath, writer, Ship::ResourceType::SOH_Background);
+
+	writer->Write((uint32_t)bg->GetRawDataSize());
 	
 	auto data = bg->parent->GetRawData();
 	writer->Write((char*)data.data() + bg->GetRawDataIndex(), bg->GetRawDataSize());

OTRExporter/OTRExporter/CMakeLists.txt

@@ -0,0 +1,245 @@
+set(PROJECT_NAME OTRExporter)
+
+################################################################################
+# Source groups
+################################################################################
+set(Header_Files
+    "AnimationExporter.h"
+    "ArrayExporter.h"
+    "AudioExporter.h"
+    "BackgroundExporter.h"
+    "BlobExporter.h"
+    "CollisionExporter.h"
+    "command_macros_base.h"
+    "CutsceneExporter.h"
+    "DisplayListExporter.h"
+    "Exporter.h"
+    "Main.h"
+    "MtxExporter.h"
+    "PathExporter.h"
+    "PlayerAnimationExporter.h"
+    "RoomExporter.h"
+    "SkeletonExporter.h"
+    "SkeletonLimbExporter.h"
+    "TextExporter.h"
+    "TextureExporter.h"
+    "VersionInfo.h"
+    "VtxExporter.h"
+    "z64cutscene.h"
+    "z64cutscene_commands.h"
+)
+source_group("Header Files" FILES ${Header_Files})
+
+set(Source_Files
+    "AnimationExporter.cpp"
+    "ArrayExporter.cpp"
+    "AudioExporter.cpp"
+    "BackgroundExporter.cpp"
+    "BlobExporter.cpp"
+    "CollisionExporter.cpp"
+    "CutsceneExporter.cpp"
+    "DisplayListExporter.cpp"
+    "Exporter.cpp"
+    "Main.cpp"
+    "MtxExporter.cpp"
+    "PathExporter.cpp"
+    "PlayerAnimationExporter.cpp"
+    "RoomExporter.cpp"
+    "SkeletonExporter.cpp"
+    "SkeletonLimbExporter.cpp"
+    "TextExporter.cpp"
+    "TextureExporter.cpp"
+    "VersionInfo.cpp"
+    "VtxExporter.cpp"
+)
+source_group("Source Files" FILES ${Source_Files})
+
+set(ALL_FILES
+    ${Header_Files}
+    ${Source_Files}
+)
+
+################################################################################
+# Target
+################################################################################
+add_library(${PROJECT_NAME} STATIC ${ALL_FILES})
+
+if (CMAKE_SYSTEM_NAME STREQUAL "Windows")
+use_props(${PROJECT_NAME} "${CMAKE_CONFIGURATION_TYPES}" "${DEFAULT_CXX_PROPS}")
+endif()
+
+set(ROOT_NAMESPACE OTRExporter)
+
+if (CMAKE_SYSTEM_NAME STREQUAL "Windows")
+	set_target_properties(${PROJECT_NAME} PROPERTIES
+		VS_GLOBAL_KEYWORD "Win32Proj"
+	)
+	if("${CMAKE_VS_PLATFORM_NAME}" STREQUAL "x64")
+		set_target_properties(${PROJECT_NAME} PROPERTIES
+			INTERPROCEDURAL_OPTIMIZATION_RELEASE "TRUE"
+		)
+	elseif("${CMAKE_VS_PLATFORM_NAME}" STREQUAL "x86")
+		set_target_properties(${PROJECT_NAME} PROPERTIES
+			INTERPROCEDURAL_OPTIMIZATION_RELEASE "TRUE"
+		)
+	endif()
+endif()
+################################################################################
+# MSVC runtime library
+################################################################################
+if (CMAKE_SYSTEM_NAME STREQUAL "Windows")
+	get_property(MSVC_RUNTIME_LIBRARY_DEFAULT TARGET ${PROJECT_NAME} PROPERTY MSVC_RUNTIME_LIBRARY)
+	if("${CMAKE_VS_PLATFORM_NAME}" STREQUAL "x64")
+		string(CONCAT "MSVC_RUNTIME_LIBRARY_STR"
+			$<$<CONFIG:Debug>:
+				MultiThreadedDebug
+			>
+			$<$<CONFIG:Release>:
+				MultiThreaded
+			>
+			$<$<NOT:$<OR:$<CONFIG:Debug>,$<CONFIG:Release>>>:${MSVC_RUNTIME_LIBRARY_DEFAULT}>
+		)
+	endif()
+	set_target_properties(${PROJECT_NAME} PROPERTIES MSVC_RUNTIME_LIBRARY ${MSVC_RUNTIME_LIBRARY_STR})
+endif()
+################################################################################
+# Compile definitions
+################################################################################
+if (CMAKE_SYSTEM_NAME STREQUAL "Windows")
+	if("${CMAKE_VS_PLATFORM_NAME}" STREQUAL "x64")
+		target_compile_definitions(${PROJECT_NAME} PRIVATE
+			"$<$<CONFIG:Debug>:"
+				"_DEBUG"
+			">"
+			"$<$<CONFIG:Release>:"
+				"NDEBUG"
+			">"
+			"_CONSOLE;"
+			"_CRT_SECURE_NO_WARNINGS;"
+			"UNICODE;"
+			"_UNICODE"
+			STORMLIB_NO_AUTO_LINK
+		)
+	elseif("${CMAKE_VS_PLATFORM_NAME}" STREQUAL "x86")
+		target_compile_definitions(${PROJECT_NAME} PRIVATE
+			"$<$<CONFIG:Debug>:"
+				"_DEBUG;"
+				"_CRT_SECURE_NO_WARNINGS"
+			">"
+			"$<$<CONFIG:Release>:"
+				"NDEBUG"
+			">"
+			"WIN32;"
+			"_CONSOLE;"
+			"UNICODE;"
+			"_UNICODE"
+			STORMLIB_NO_AUTO_LINK
+		)
+	endif()
+endif()
+
+if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU|Clang|AppleClang")
+	target_compile_definitions(${PROJECT_NAME} PRIVATE
+		"$<$<CONFIG:Debug>:"
+				"_DEBUG"
+		">"
+		"$<$<CONFIG:Release>:"
+			"NDEBUG"
+		">"
+		"_CONSOLE;"
+		"_CRT_SECURE_NO_WARNINGS;"
+		"UNICODE;"
+		"_UNICODE"
+	)
+endif()
+################################################################################
+# Compile and link options
+################################################################################
+
+target_include_directories(${PROJECT_NAME} PRIVATE
+	${CMAKE_CURRENT_SOURCE_DIR}/../../ZAPDTR/ZAPD/
+    ${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/include
+    # TODO: these should no longer be necessary if we were to link against LUS
+    ${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship
+    ${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/src
+    ${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/extern
+    ${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/extern/Mercury
+    ${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/extern/tinyxml2
+    ${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/extern/ZAPDUtils
+	${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/extern/StormLib/src
+    ${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/extern/spdlog/include
+    ${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/extern/nlohmann-json/include
+    ${CMAKE_CURRENT_SOURCE_DIR}/../../libultraship/src/resource
+    ${CMAKE_CURRENT_SOURCE_DIR}/../../soh/soh
+	.
+)
+
+if(MSVC)
+    if("${CMAKE_VS_PLATFORM_NAME}" STREQUAL "x64")
+        target_compile_options(${PROJECT_NAME} PRIVATE
+            $<$<CONFIG:Release>:
+                /Oi;
+                /Gy
+            >
+            /permissive-;
+            /sdl;
+            /W3;
+            ${DEFAULT_CXX_DEBUG_INFORMATION_FORMAT};
+            ${DEFAULT_CXX_EXCEPTION_HANDLING}
+        )
+    elseif("${CMAKE_VS_PLATFORM_NAME}" STREQUAL "x86")
+        target_compile_options(${PROJECT_NAME} PRIVATE
+            $<$<CONFIG:Release>:
+                /Oi;
+                /Gy
+            >
+            /permissive-;
+            /sdl;
+            /W3;
+            ${DEFAULT_CXX_DEBUG_INFORMATION_FORMAT};
+            ${DEFAULT_CXX_EXCEPTION_HANDLING}
+        )
+    endif()
+    if("${CMAKE_VS_PLATFORM_NAME}" STREQUAL "x64")
+        target_link_options(${PROJECT_NAME} PRIVATE
+            $<$<CONFIG:Release>:
+                /OPT:REF;
+                /OPT:ICF
+            >
+            /SUBSYSTEM:CONSOLE
+        )
+    elseif("${CMAKE_VS_PLATFORM_NAME}" STREQUAL "x86")
+        target_link_options(${PROJECT_NAME} PRIVATE
+            $<$<CONFIG:Release>:
+                /DEBUG;
+                /OPT:REF;
+                /OPT:ICF;
+                /INCREMENTAL:NO
+            >
+            /SUBSYSTEM:CONSOLE
+        )
+    endif()
+endif()
+
+if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU|Clang|AppleClang")
+	target_compile_options(${PROJECT_NAME} PRIVATE
+		-Wall -Wextra -Wno-error
+        -Wno-unused-parameter
+        -Wno-unused-function
+        -Wno-unused-variable
+		-Wno-missing-field-initializers
+        -Wno-parentheses
+        -Wno-narrowing
+        $<$<COMPILE_LANGUAGE:CXX>:-Wno-deprecated-enum-enum-conversion>
+	)
+endif()
+################################################################################
+# Dependencies
+################################################################################
+add_dependencies(${PROJECT_NAME}
+    libultraship
+)
+
+# Link with other targets.
+target_link_libraries(${PROJECT_NAME} PUBLIC "${ADDITIONAL_LIBRARY_DEPENDENCIES}")
+

OTRExporter/OTRExporter/CollisionExporter.cpp

@@ -1,11 +1,11 @@
 #include "CollisionExporter.h"
-#include <Resource.h>
+#include <libultraship/bridge.h>
 
 void OTRExporter_Collision::Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer)
 {
 	ZCollisionHeader* col = (ZCollisionHeader*)res;
 
-	WriteHeader(res, outPath, writer, Ship::ResourceType::CollisionHeader);
+	WriteHeader(res, outPath, writer, Ship::ResourceType::SOH_CollisionHeader);
 	
 	writer->Write(col->absMinX);
 	writer->Write(col->absMinY);

OTRExporter/OTRExporter/CutsceneExporter.cpp

@@ -1,11 +1,11 @@
 #include "CutsceneExporter.h"
-#include <Resource.h>
+#include <libultraship/bridge.h>
 
 void OTRExporter_Cutscene::Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer)
 {
 	ZCutscene* cs = (ZCutscene*)res;
 
-	WriteHeader(cs, outPath, writer, Ship::ResourceType::Cutscene);
+	WriteHeader(cs, outPath, writer, Ship::ResourceType::SOH_Cutscene);
 
 	//writer->Write((uint32_t)cs->commands.size() + 2 + 2);
 	writer->Write((uint32_t)0);
@@ -29,7 +29,7 @@ void OTRExporter_Cutscene::Save(ZResource* res, const fs::path& outPath, BinaryW
 			for (auto& e : ((CutsceneCommandSetCameraPos*)cs->commands[i])->entries)
 			{
 				writer->Write(CMD_BBH(e->continueFlag, e->cameraRoll, e->nextPointFrame));
-				writer->Write(CMD_F(e->viewAngle));
+				writer->Write(e->viewAngle);
 				writer->Write(CMD_HH(e->posX, e->posY));
 				writer->Write(CMD_HH(e->posZ, e->unused));
 			}
@@ -46,7 +46,7 @@ void OTRExporter_Cutscene::Save(ZResource* res, const fs::path& outPath, BinaryW
 			for (auto& e : ((CutsceneCommandSetCameraPos*)cs->commands[i])->entries)
 			{
 				writer->Write(CMD_BBH(e->continueFlag, e->cameraRoll, e->nextPointFrame));
-				writer->Write(CMD_F(e->viewAngle));
+				writer->Write(e->viewAngle);
 				writer->Write(CMD_HH(e->posX, e->posY));
 				writer->Write(CMD_HH(e->posZ, e->unused));
 			}
@@ -105,7 +105,7 @@ void OTRExporter_Cutscene::Save(ZResource* res, const fs::path& outPath, BinaryW
 			for (auto& e : ((CutsceneCommandSetCameraPos*)cs->commands[i])->entries)
 			{
 				writer->Write(CMD_BBH(e->continueFlag, e->cameraRoll, e->nextPointFrame));
-				writer->Write(CMD_F(e->viewAngle));
+				writer->Write(e->viewAngle);
 				writer->Write(CMD_HH(e->posX, e->posY));
 				writer->Write(CMD_HH(e->posZ, e->unused));
 			}
@@ -122,7 +122,7 @@ void OTRExporter_Cutscene::Save(ZResource* res, const fs::path& outPath, BinaryW
 			for (auto& e : ((CutsceneCommandSetCameraPos*)cs->commands[i])->entries)
 			{
 				writer->Write(CMD_BBH(e->continueFlag, e->cameraRoll, e->nextPointFrame));
-				writer->Write(CMD_F(e->viewAngle));
+				writer->Write(e->viewAngle);
 				writer->Write(CMD_HH(e->posX, e->posY));
 				writer->Write(CMD_HH(e->posZ, e->unused));
 			}

OTRExporter/OTRExporter/DisplayListExporter.cpp

@@ -3,9 +3,9 @@
 #include "../ZAPD/ZFile.h"
 #include <Utils/MemoryStream.h>
 #include <Utils/BitConverter.h>
-#include "Lib/StrHash64.h"
+#include "StrHash64/StrHash64.h"
 #include "spdlog/spdlog.h"
-#include "PR/ultra64/gbi.h"
+#include <libultraship/libultra/gbi.h>
 #include <Globals.h>
 #include <iostream>
 #include <string>
@@ -29,20 +29,6 @@
                    Ab1, Ad1))       \
 }
 
-typedef int32_t Mtx_t[4][4];
-
-typedef union Mtx
-{
-	//_Alignas(8)
-		Mtx_t		m;
-	int32_t		l[16];
-	struct
-	{
-		int16_t		i[16];
-		uint16_t	f[16];
-	};
-} Mtx;
-
 #define gsSPBranchLessZraw2(dl, vtx, zval)               \
 {   _SHIFTL(G_BRANCH_Z,24,8)|_SHIFTL((vtx)*5,12,12)|_SHIFTL((vtx)*2,0,12),\
     (unsigned int)(zval),                       }
@@ -71,7 +57,7 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 
 	// DEBUG: Write in a marker
 	Declaration* dbgDecl = dList->parent->GetDeclaration(dList->GetRawDataIndex());
-	std::string dbgName = StringHelper::Sprintf("%s\\%s", GetParentFolderName(res).c_str(), dbgDecl->varName.c_str());
+	std::string dbgName = StringHelper::Sprintf("%s/%s", GetParentFolderName(res).c_str(), dbgDecl->varName.c_str());
 	uint64_t hash = CRC64(dbgName.c_str());
 	writer->Write((uint32_t)(G_MARKER << 24));
 	writer->Write((uint32_t)0xBEEFBEEF);
@@ -81,7 +67,7 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 	auto dlStart = std::chrono::steady_clock::now();
 
 	//for (auto data : dList->instructions)
-	for (int dataIdx = 0; dataIdx < dList->instructions.size(); dataIdx++)
+	for (size_t dataIdx = 0; dataIdx < dList->instructions.size(); dataIdx++)
 	{
 		auto data = dList->instructions[dataIdx];
 		uint32_t word0 = 0;
@@ -110,14 +96,14 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 		{
 		case G_NOOP:
 		{
-			Gfx value = gsDPNoOp();
+			Gfx value = {gsDPNoOp()};
 			word0 = value.words.w0;
 			word1 = value.words.w1;
 		}
 		break;
 		case G_ENDDL:
 		{
-			Gfx value = gsSPEndDisplayList();
+			Gfx value = {gsSPEndDisplayList()};
 			word0 = value.words.w0;
 			word1 = value.words.w1;
 		}
@@ -128,7 +114,7 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 			int32_t nnnn = (data & 0x0000FFFF00000000ULL) >> 32;
 			int32_t vvvvvvvv = (data & 0x00000000FFFFFFFFULL);
 
-			Gfx value = gsSPModifyVertex(nnnn / 2, ww, vvvvvvvv);
+			Gfx value = {gsSPModifyVertex(nnnn / 2, ww, vvvvvvvv)};
 			word0 = value.words.w0;
 			word1 = value.words.w1;
 		}
@@ -145,35 +131,35 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 			int32_t cccccc = (data & 0x00FFFFFF00000000) >> 32;
 			int32_t ssssssss = (data & 0xFFFFFFFF);
 
-			Gfx value = gsSPGeometryMode(~cccccc, ssssssss);
+			Gfx value = {gsSPGeometryMode(~cccccc, ssssssss)};
 			word0 = value.words.w0;
 			word1 = value.words.w1;
 		}
 		break;
 		case G_RDPPIPESYNC:
 		{
-			Gfx value = gsDPPipeSync();
+			Gfx value = {gsDPPipeSync()};
 			word0 = value.words.w0;
 			word1 = value.words.w1;
 		}
 		break;
 		case G_RDPLOADSYNC:
 		{
-			Gfx value = gsDPLoadSync();
+			Gfx value = {gsDPLoadSync()};
 			word0 = value.words.w0;
 			word1 = value.words.w1;
 		}
 		break;
 		case G_RDPTILESYNC:
 		{
-			Gfx value = gsDPTileSync();
+			Gfx value = {gsDPTileSync()};
 			word0 = value.words.w0;
 			word1 = value.words.w1;
 		}
 		break;
 		case G_RDPFULLSYNC:
 		{
-			Gfx value = gsDPFullSync();
+			Gfx value = {gsDPFullSync()};
 			word0 = value.words.w0;
 			word1 = value.words.w1;
 		}
@@ -183,14 +169,14 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 			int32_t hhhhhh = (data & 0x00FFFFFF00000000) >> 32;
 			int32_t llllllll = (data & 0x00000000FFFFFFFF);
 
-			Gfx value = gsDPSetOtherMode(hhhhhh, llllllll);
+			Gfx value = {gsDPSetOtherMode(hhhhhh, llllllll)};
 			word0 = value.words.w0;
 			word1 = value.words.w1;
 		}
 		break;
 		case G_POPMTX:
 		{
-			Gfx value = gsSPPopMatrix(data);
+			Gfx value = {gsSPPopMatrix(data)};
 			word0 = value.words.w0;
 			word1 = value.words.w1;
 		}
@@ -202,23 +188,23 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 			uint8_t b = (uint8_t)((data & 0xFF00FF00) >> 8);
 			uint8_t a = (uint8_t)((data & 0x000000FF) >> 0);
 
-			Gfx value = gsDPSetEnvColor(r, g, b, a);
+			Gfx value = {gsDPSetEnvColor(r, g, b, a)};
 			word0 = value.words.w0;
 			word1 = value.words.w1;
 		}
 		break;
 		case G_MTX:
 		{
-			if ((!Globals::Instance->HasSegment(GETSEGNUM(data))) || ((data & 0xFFFFFFFF) == 0x07000000)) // En_Zf and En_Ny place a DL in segment 7
+			if ((!Globals::Instance->HasSegment(GETSEGNUM(data), res->parent->workerID)) || ((data & 0xFFFFFFFF) == 0x07000000)) // En_Zf and En_Ny place a DL in segment 7
 			{
 				uint32_t pp = (data & 0x000000FF00000000) >> 32;
 				uint32_t mm = (data & 0x00000000FFFFFFFF);
 
 				pp ^= G_MTX_PUSH;
 
-				mm = (mm & 0x0FFFFFFF) + 0xF0000000;
+				mm = (mm & 0x0FFFFFFF) + 1;
 
-				Gfx value = gsSPMatrix(mm, pp);
+				Gfx value = {gsSPMatrix(mm, pp)};
 				word0 = value.words.w0;
 				word1 = value.words.w1;
 			}
@@ -228,7 +214,7 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 				uint32_t mm = (data & 0x00000000FFFFFFFF);
 				pp ^= G_MTX_PUSH;
 
-				Gfx value = gsSPMatrix(mm, pp);
+				Gfx value = {gsSPMatrix(mm, pp)};
 				word0 = value.words.w0;
 				word1 = value.words.w1;
 
@@ -243,7 +229,7 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 
 				if (mtxDecl != nullptr)
 				{
-					std::string vName = StringHelper::Sprintf("%s\\%s", (GetParentFolderName(res).c_str()), mtxDecl->varName.c_str());
+					std::string vName = StringHelper::Sprintf("%s/%s", (GetParentFolderName(res).c_str()), mtxDecl->varName.c_str());
 
 					uint64_t hash = CRC64(vName.c_str());
 
@@ -267,7 +253,7 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 			int32_t xxx = (data & 0x0000000000FFF000) >> 12;
 			int32_t ddd = (data & 0x0000000000000FFF);
 
-			Gfx value = gsDPLoadBlock(i, sss, ttt, xxx, ddd);
+			Gfx value = {gsDPLoadBlock(i, sss, ttt, xxx, ddd)};
 			word0 = value.words.w0;
 			word1 = value.words.w1;
 		}
@@ -277,7 +263,7 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 			int32_t vvvv = (data & 0xFFFF00000000) >> 32;
 			int32_t wwww = (data & 0x0000FFFF);
 
-			Gfx value = gsSPCullDisplayList(vvvv / 2, wwww / 2);
+			Gfx value = {gsSPCullDisplayList(vvvv / 2, wwww / 2)};
 			word0 = value.words.w0;
 			word1 = value.words.w1;
 		}
@@ -293,7 +279,7 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 				uint32_t z = (data & 0x00000000FFFFFFFF) >> 0;
 				uint32_t h = (data & 0xFFFFFFFF);
 
-				Gfx value = gsSPBranchLessZraw3(h & 0x00FFFFFF);
+				Gfx value = {gsSPBranchLessZraw3(h & 0x00FFFFFF)};
 				word0 = value.words.w0;
 				word1 = value.words.w1;
 			}
@@ -306,7 +292,7 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 			break;
 		case G_RDPHALF_2:
 		{
-			Gfx value = gsDPWordLo(data & 0xFFFFFFFF);
+			Gfx value = {gsDPWordLo(data & 0xFFFFFFFF)};
 			word0 = value.words.w0;
 			word1 = value.words.w1;
 		}
@@ -319,7 +305,7 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 			int32_t XXX = (data & 0x0000000000FFF000) >> 12;
 			int32_t YYY = (data & 0x0000000000000FFF);
 
-			Gfx value = gsSPTextureRectangle2(XXX, YYY, xxx, yyy, i);
+			Gfx value = {gsSPTextureRectangle2(XXX, YYY, xxx, yyy, i)};
 			word0 = value.words.w0;
 			word1 = value.words.w1;
 		}
@@ -338,7 +324,7 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 
 			int bp = 0;
 
-			Gfx value = gsSPBranchLessZraw2(0xDEADABCD, (a / 5) | (b / 2), z);
+			Gfx value = {gsSPBranchLessZraw2(0xDEADABCD, (a / 5) | (b / 2), z)};
 			word0 = (value.words.w0 & 0x00FFFFFF) + (G_BRANCH_Z_OTR << 24);
 			word1 = value.words.w1;
 
@@ -347,7 +333,7 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 
 			if (dListDecl != nullptr)
 			{
-				std::string vName = StringHelper::Sprintf("%s\\%s", (GetParentFolderName(res).c_str()), dListDecl->varName.c_str());
+				std::string vName = StringHelper::Sprintf("%s/%s", (GetParentFolderName(res).c_str()), dListDecl->varName.c_str());
 
 				uint64_t hash = CRC64(vName.c_str());
 
@@ -370,21 +356,13 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 					//std::string fName = StringHelper::Sprintf("%s\\%s", GetParentFolderName(res).c_str(), dListDecl2->varName.c_str());
 					std::string fName = OTRExporter_DisplayList::GetPathToRes(res, dListDecl2->varName.c_str());
 
-					if (!File::Exists("Extract\\" + fName))
+					if (files.find(fName) == files.end() && !File::Exists("Extract/" + fName))
 					{
 						MemoryStream* dlStream = new MemoryStream();
 						BinaryWriter dlWriter = BinaryWriter(dlStream);
 
 						Save(dList->otherDLists[i], outPath, &dlWriter);
-
-#ifdef _DEBUG
-						//if (otrArchive->HasFile(fName))
-							//otrArchive->RemoveFile(fName);
-#endif
-
-						File::WriteAllBytes("Extract\\" + fName, dlStream->ToVector());
-
-						//otrArchive->AddFile(fName, (uintptr_t)dlStream->ToVector().data(), dlWriter.GetBaseAddress());
+						AddFile(fName, dlStream->ToVector());
 					}
 				}
 				else
@@ -401,19 +379,19 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 		//case G_BRANCH_Z:
 		case G_DL:
 		{
-			if ((!Globals::Instance->HasSegment(GETSEGNUM(data)) && (int)opF3D != G_BRANCH_Z)
+			if ((!Globals::Instance->HasSegment(GETSEGNUM(data), res->parent->workerID) && (int)opF3D != G_BRANCH_Z)
 				|| ((data & 0xFFFFFFFF) == 0x07000000)) // En_Zf and En_Ny place a DL in segment 7
 			{
 				int32_t pp = (data & 0x00FF000000000000) >> 56;
 
 				Gfx value;
 
-				u32 dListVal = (data & 0x0FFFFFFF) + 0xF0000000;
+				u32 dListVal = (data & 0x0FFFFFFF) + 1;
 
 				if (pp != 0)
-					value = gsSPBranchList(dListVal);
+					value = {gsSPBranchList(dListVal)};
 				else
-					value = gsSPDisplayList(dListVal);
+					value = {gsSPDisplayList(dListVal)};
 
 				word0 = value.words.w0;
 				word1 = value.words.w1;
@@ -441,7 +419,7 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 
 				if (dListDecl != nullptr)
 				{
-					std::string vName = StringHelper::Sprintf("%s\\%s", (GetParentFolderName(res).c_str()), dListDecl->varName.c_str());
+					std::string vName = StringHelper::Sprintf("%s/%s", (GetParentFolderName(res).c_str()), dListDecl->varName.c_str());
 
 					uint64_t hash = CRC64(vName.c_str());
 
@@ -464,14 +442,14 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 						//std::string fName = StringHelper::Sprintf("%s\\%s", GetParentFolderName(res).c_str(), dListDecl2->varName.c_str());
 						std::string fName = OTRExporter_DisplayList::GetPathToRes(res, dListDecl2->varName.c_str());
 
-						if (!File::Exists("Extract\\" + fName))
+						if (files.find(fName) == files.end() && !File::Exists("Extract/" + fName))
 						{
 							MemoryStream* dlStream = new MemoryStream();
 							BinaryWriter dlWriter = BinaryWriter(dlStream);
 
 							Save(dList->otherDLists[i], outPath, &dlWriter);
 
-							File::WriteAllBytes("Extract\\" + fName, dlStream->ToVector());
+							AddFile(fName, dlStream->ToVector());
 						}
 					}
 					else
@@ -491,7 +469,7 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 			int32_t ddd = (____ & 0x700) >> 8;
 			int32_t nnnnnnn = (____ & 0xFE) >> 1;
 
-			Gfx value = gsSPTexture(ssss, tttt, lll, ddd, nnnnnnn);
+			Gfx value = {gsSPTexture(ssss, tttt, lll, ddd, nnnnnnn)};
 			word0 = value.words.w0;
 			word1 = value.words.w1;
 		}
@@ -502,7 +480,7 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 			int32_t bb = ((data & 0x0000FF0000000000ULL) >> 40) / 2;
 			int32_t cc = ((data & 0x000000FF00000000ULL) >> 32) / 2;
 
-			Gfx test = gsSP1Triangle(aa, bb, cc, 0);
+			Gfx test = {gsSP1Triangle(aa, bb, cc, 0)};
 			word0 = test.words.w0;
 			word1 = test.words.w1;
 		}
@@ -516,7 +494,7 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 			int32_t ee = ((data & 0x0000000000FF00ULL) >> 8) / 2;
 			int32_t ff = ((data & 0x000000000000FFULL) >> 0) / 2;
 
-			Gfx test = gsSP2Triangles(aa, bb, cc, 0, dd, ee, ff, 0);
+			Gfx test = {gsSP2Triangles(aa, bb, cc, 0, dd, ee, ff, 0)};
 			word0 = test.words.w0;
 			word1 = test.words.w1;
 		}
@@ -527,8 +505,8 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 			int32_t bb = ((data & 0x0000FF0000000000ULL) >> 40) / 2;
 			int32_t cc = ((data & 0x000000FF00000000ULL) >> 32) / 2;
 			int32_t dd = ((data & 0x000000000000FFULL)) / 2;
-			
-			Gfx test = gsSP1Quadrangle(aa, bb, cc, dd, 0);
+
+			Gfx test = {gsSP1Quadrangle(aa, bb, cc, dd, 0)};
 			word0 = test.words.w0;
 			word1 = test.words.w1;
 		}
@@ -542,7 +520,7 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 			int32_t bb = (data & 0x000000000000FF00) >> 8;
 			int32_t aa = (data & 0x00000000000000FF) >> 0;
 
-			Gfx value = gsDPSetPrimColor(mm, ff, rr, gg, bb, aa);
+			Gfx value = {gsDPSetPrimColor(mm, ff, rr, gg, bb, aa)};
 			word0 = value.words.w0;
 			word1 = value.words.w1;
 		}
@@ -556,7 +534,7 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 
 			// TODO: Output the correct render modes in data
 
-			Gfx value = gsSPSetOtherMode(0xE2, sft, len, dd);
+			Gfx value = {gsSPSetOtherMode(0xE2, sft, len, dd)};
 			word0 = value.words.w0;
 			word1 = value.words.w1;
 		}
@@ -574,11 +552,11 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 			if (sft == 14)  // G_MDSFT_TEXTLUT
 			{
 				const char* types[] = { "G_TT_NONE", "G_TT_NONE", "G_TT_RGBA16", "G_TT_IA16" };
-				value = gsDPSetTextureLUT(dd >> 14);
+				value = {gsDPSetTextureLUT(dd >> 14)};
 			}
 			else
 			{
-				value = gsSPSetOtherMode(0xE3, sft, nn + 1, dd);
+				value = {gsSPSetOtherMode(0xE3, sft, nn + 1, dd)};
 			}
 
 			word0 = value.words.w0;
@@ -605,7 +583,7 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 			int32_t bbbb = (data & 0b0000000000000000000000000000000000000000000000000000000011110000) >> 4;
 			int32_t uuuu = (data & 0b0000000000000000000000000000000000000000000000000000000000001111);
 
-			Gfx value = gsDPSetTile(fff, ii, nnnnnnnnn, mmmmmmmmm, ttt, pppp, cc, aaaa, ssss, dd, bbbb, uuuu);
+			Gfx value = {gsDPSetTile(fff, ii, nnnnnnnnn, mmmmmmmmm, ttt, pppp, cc, aaaa, ssss, dd, bbbb, uuuu)};
 			word0 = value.words.w0;
 			word1 = value.words.w1;
 		}
@@ -629,7 +607,7 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 			int32_t ab1 = (data & 0b00000000000000000000000000000000000000000000000000000000111000) >> 3;
 			int32_t ad1 = (data & 0b00000000000000000000000000000000000000000000000000000000000111) >> 0;
 
-			Gfx value = gsDPSetCombineLERP2(a0, b0, c0, d0, aa0, ab0, ac0, ad0, a1, b1, c1, d1, aa1, ab1, ac1, ad1);
+			Gfx value = {gsDPSetCombineLERP2(a0, b0, c0, d0, aa0, ab0, ac0, ad0, a1, b1, c1, d1, aa1, ab1, ac1, ad1)};
 			word0 = value.words.w0;
 			word1 = value.words.w1;
 		}
@@ -642,7 +620,7 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 			int32_t vvv = (data & 0x0000000000000FFF);
 			int32_t i = (data & 0x000000000F000000) >> 24;
 
-			Gfx value = gsDPSetTileSize(i, sss, ttt, uuu, vvv);
+			Gfx value = {gsDPSetTileSize(i, sss, ttt, uuu, vvv)};
 			word0 = value.words.w0;
 			word1 = value.words.w1;
 		}
@@ -652,7 +630,7 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 			int32_t t = (data & 0x0000000007000000) >> 24;
 			int32_t ccc = (data & 0x00000000003FF000) >> 14;
 
-			Gfx value = gsDPLoadTLUTCmd(t, ccc);
+			Gfx value = {gsDPLoadTLUTCmd(t, ccc)};
 			word0 = value.words.w0;
 			word1 = value.words.w1;
 		}
@@ -661,11 +639,11 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 		{
 			int sss =	(data & 0x00FFF00000000000) >> 44;
 			int ttt =	(data & 0x00000FFF00000000) >> 32;
-			int i =		(data & 0x000000000F000000) >> 16;
+			int i =		(data & 0x000000000F000000) >> 24;
 			int uuu =	(data & 0x0000000000FFF000) >> 12;
 			int vvv=	(data & 0x0000000000000FFF);
 
-			Gfx value = gsDPLoadTile(i, sss, ttt, uuu, vvv);
+			Gfx value = {gsDPLoadTile(i, sss, ttt, uuu, vvv)};
 			word0 = value.words.w0;
 			word1 = value.words.w1;
 		}
@@ -675,15 +653,20 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 			uint32_t seg = data & 0xFFFFFFFF;
 			int32_t texAddress = Seg2Filespace(data, dList->parent->baseAddress);
 
-			if (!Globals::Instance->HasSegment(GETSEGNUM(seg)))
+			if (!Globals::Instance->HasSegment(GETSEGNUM(seg), res->parent->workerID) || (res->GetName() == "sShadowMaterialDL"))
 			{
+				if (res->GetName() == "sShadowMaterialDL") {
+					// sShadowMaterialDL (In ovl_En_Jsjutan) has a texture in bss. This is a hack to override the reference to one
+					// to segment C. The actor has been modified to load the texture into segment C.
+					seg = 0x0C000000;
+				}
 				int32_t __ = (data & 0x00FF000000000000) >> 48;
 				int32_t www = (data & 0x00000FFF00000000) >> 32;
 
 				uint32_t fmt = (__ & 0xE0) >> 5;
 				uint32_t siz = (__ & 0x18) >> 3;
 
-				Gfx value = gsDPSetTextureImage(fmt, siz, www - 1, (seg & 0x0FFFFFFF) + 0xF0000000);
+				Gfx value = {gsDPSetTextureImage(fmt, siz, www + 1, (seg & 0x0FFFFFFF) + 1)};
 				word0 = value.words.w0;
 				word1 = value.words.w1;
 
@@ -693,7 +676,7 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 			else
 			{
 				std::string texName = "";
-				bool foundDecl = Globals::Instance->GetSegmentedPtrName(seg, dList->parent, "", texName);
+				bool foundDecl = Globals::Instance->GetSegmentedPtrName(seg, dList->parent, "", texName, res->parent->workerID);
 
 				int32_t __ = (data & 0x00FF000000000000) >> 48;
 				int32_t www = (data & 0x00000FFF00000000) >> 32;
@@ -701,7 +684,7 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 				uint32_t fmt = (__ & 0xE0) >> 5;
 				uint32_t siz = (__ & 0x18) >> 3;
 
-				Gfx value = gsDPSetTextureImage(fmt, siz, www - 1, __);
+				Gfx value = {gsDPSetTextureImage(fmt, siz, www + 1, __)};
 				word0 = value.words.w0 & 0x00FFFFFF;
 				word0 += (G_SETTIMG_OTR << 24);
 				//word1 = value.words.w1;
@@ -712,10 +695,10 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 
 				if (foundDecl)
 				{
-					ZFile* assocFile = Globals::Instance->GetSegment(GETSEGNUM(seg));
+					ZFile* assocFile = Globals::Instance->GetSegment(GETSEGNUM(seg), res->parent->workerID);
 					std::string assocFileName = assocFile->GetName();
 					std::string fName = "";
-					
+
 					if (GETSEGNUM(seg) == SEGMENT_SCENE || GETSEGNUM(seg) == SEGMENT_ROOM)
 						fName = GetPathToRes(res, texName.c_str());
 					else
@@ -744,48 +727,13 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 				int32_t aa = (data & 0x000000FF00000000ULL) >> 32;
 				int32_t nn = (data & 0x000FF00000000000ULL) >> 44;
 
-				Gfx value = gsSPVertex(data & 0xFFFFFFFF, nn, ((aa >> 1) - nn));
+				Gfx value = {gsSPVertex(data & 0xFFFFFFFF, nn, ((aa >> 1) - nn))};
 
 				word0 = value.words.w0;
-				word1 = value.words.w1 | 0xF0000000;
+				word1 = value.words.w1 | 1;
 			}
 			else
-			//if (dList->vertices.size() > 0)
 			{
-				// Connect neighboring vertex arrays
-				std::vector<std::pair<uint32_t, std::vector<ZVtx>>> vertsKeys(dList->vertices.begin(),
-					dList->vertices.end());
-
-				if (vertsKeys.size() > 0)
-				{
-					auto lastItem = vertsKeys[0];
-
-					for (size_t i = 1; i < vertsKeys.size(); i++)
-					{
-						auto curItem = vertsKeys[i];
-
-						int32_t sizeDiff = curItem.first - (lastItem.first + (lastItem.second.size() * 16));
-
-						// Make sure there isn't an unaccounted inbetween these two
-						if (sizeDiff == 0)
-						{
-							for (auto v : curItem.second)
-							{
-								dList->vertices[lastItem.first].push_back(v);
-								lastItem.second.push_back(v);
-							}
-
-							dList->vertices.erase(curItem.first);
-							vertsKeys.erase(vertsKeys.begin() + i);
-
-							i--;
-							continue;
-						}
-
-						lastItem = curItem;
-					}
-				}
-
 				// Write CRC64 of vtx file name
 				uint32_t addr = data & 0xFFFFFFFF;
 
@@ -793,10 +741,7 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 					addr -= dList->parent->baseAddress;
 
 				auto segOffset = GETSEGOFFSET(addr);
-				//uint32_t seg = data & 0xFFFFFFFF;
 				Declaration* vtxDecl = dList->parent->GetDeclarationRanged(segOffset);
-				//std::string vtxName = "";
-				//bool foundDecl = Globals::Instance->GetSegmentedPtrName(seg, dList->parent, "", vtxName);
 
 				int32_t aa = (data & 0x000000FF00000000ULL) >> 32;
 				int32_t nn = (data & 0x000FF00000000000ULL) >> 44;
@@ -805,7 +750,7 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 				{
 					uint32_t diff = segOffset - vtxDecl->address;
 
-					Gfx value = gsSPVertex(diff, nn, ((aa >> 1) - nn));
+					Gfx value = {gsSPVertex(diff, nn, ((aa >> 1) - nn))};
 
 					word0 = value.words.w0;
 					word0 &= 0x00FFFFFF;
@@ -822,9 +767,8 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 					word0 = hash >> 32;
 					word1 = hash & 0xFFFFFFFF;
 
-					if (!File::Exists("Extract\\" + fName))
+					if (files.find(fName) == files.end() && !File::Exists("Extract/" + fName))
 					{
-						//printf("Exporting VTX Data %s\n", fName.c_str());
 						// Write vertices to file
 						MemoryStream* vtxStream = new MemoryStream();
 						BinaryWriter vtxWriter = BinaryWriter(vtxStream);
@@ -833,7 +777,7 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 
 						auto split = StringHelper::Split(vtxDecl->text, "\n");
 
-						for (int i = 0; i < split.size(); i++)
+						for (size_t i = 0; i < split.size(); i++)
 						{
 							std::string line = split[i];
 
@@ -847,44 +791,37 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 						vtxWriter.Write((uint32_t)ZResourceType::Vertex);
 						vtxWriter.Write((uint32_t)arrCnt);
 
-						size_t sz = dList->vertices[vtxDecl->address].size();
+						auto start = std::chrono::steady_clock::now();
 
-						//if (sz > 0)
+						// God dammit this is so dumb
+						for (size_t i = 0; i < split.size(); i++)
 						{
-							auto start = std::chrono::steady_clock::now();
+							std::string line = split[i];
 
-							// God dammit this is so dumb
-							for (size_t i = 0; i < split.size(); i++)
+							if (StringHelper::Contains(line, "VTX("))
 							{
-								std::string line = split[i];
+								auto split2 = StringHelper::Split(StringHelper::Split(StringHelper::Split(line, "VTX(")[1], ")")[0], ",");
 
-								if (StringHelper::Contains(line, "VTX("))
-								{
-									auto split2 = StringHelper::Split(StringHelper::Split(StringHelper::Split(line, "VTX(")[1], ")")[0], ",");
+								vtxWriter.Write((int16_t)std::stoi(split2[0], nullptr, 10)); // v.x
+								vtxWriter.Write((int16_t)std::stoi(split2[1], nullptr, 10)); // v.y
+								vtxWriter.Write((int16_t)std::stoi(split2[2], nullptr, 10)); // v.z
 
-									vtxWriter.Write((int16_t)std::stoi(split2[0], nullptr, 10)); // v.x
-									vtxWriter.Write((int16_t)std::stoi(split2[1], nullptr, 10)); // v.y
-									vtxWriter.Write((int16_t)std::stoi(split2[2], nullptr, 10)); // v.z
+								vtxWriter.Write((int16_t)0);								 // v.flag
 
-									vtxWriter.Write((int16_t)0);								 // v.flag
-									
-									vtxWriter.Write((int16_t)std::stoi(split2[3], nullptr, 10)); // v.s
-									vtxWriter.Write((int16_t)std::stoi(split2[4], nullptr, 10)); // v.t
-									
-									vtxWriter.Write((uint8_t)std::stoi(split2[5], nullptr, 10)); // v.r
-									vtxWriter.Write((uint8_t)std::stoi(split2[6], nullptr, 10)); // v.g
-									vtxWriter.Write((uint8_t)std::stoi(split2[7], nullptr, 10)); // v.b
-									vtxWriter.Write((uint8_t)std::stoi(split2[8], nullptr, 10)); // v.a
-								}
+								vtxWriter.Write((int16_t)std::stoi(split2[3], nullptr, 10)); // v.s
+								vtxWriter.Write((int16_t)std::stoi(split2[4], nullptr, 10)); // v.t
+
+								vtxWriter.Write((uint8_t)std::stoi(split2[5], nullptr, 10)); // v.r
+								vtxWriter.Write((uint8_t)std::stoi(split2[6], nullptr, 10)); // v.g
+								vtxWriter.Write((uint8_t)std::stoi(split2[7], nullptr, 10)); // v.b
+								vtxWriter.Write((uint8_t)std::stoi(split2[8], nullptr, 10)); // v.a
 							}
-
-							File::WriteAllBytes("Extract\\" + fName, vtxStream->ToVector());
-
-							auto end = std::chrono::steady_clock::now();
-							size_t diff = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
-
-							//printf("Exported VTX Array %s in %zums\n", fName.c_str(), diff);
 						}
+
+						AddFile(fName, vtxStream->ToVector());
+
+						auto end = std::chrono::steady_clock::now();
+						size_t diff = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
 					}
 				}
 				else
@@ -892,19 +829,10 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 					spdlog::error("vtxDecl == nullptr!");
 				}
 			}
-			/*else
-			{
-				writer->Write(word0);
-				writer->Write(word1);
-				word0 = 0;
-				word1 = 0;
-
-				spdlog::error("dList->vertices.size() <= 0!");
-			}*/
 		}
 		break;
 		}
-	
+
 		writer->Write(word0);
 		writer->Write(word1);
 	}
@@ -918,7 +846,7 @@ void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, Bina
 std::string OTRExporter_DisplayList::GetPathToRes(ZResource* res, std::string varName)
 {
 	std::string prefix = GetPrefix(res);
-	std::string fName = StringHelper::Sprintf("%s\\%s", GetParentFolderName(res).c_str(), varName.c_str());
+	std::string fName = StringHelper::Sprintf("%s/%s", GetParentFolderName(res).c_str(), varName.c_str());
 
 	return fName;
 }
@@ -932,7 +860,7 @@ std::string OTRExporter_DisplayList::GetParentFolderName(ZResource* res)
 	{
 		auto split = StringHelper::Split(oName, "_");
 		oName = "";
-		for (int i = 0; i < split.size() - 1; i++)
+		for (size_t i = 0; i < split.size() - 1; i++)
 			oName += split[i] + "_";
 
 		oName += "scene";
@@ -943,7 +871,7 @@ std::string OTRExporter_DisplayList::GetParentFolderName(ZResource* res)
 	}
 
 	if (prefix != "")
-		oName = prefix + "\\" + oName;
+		oName = prefix + "/" + oName;
 
 	return oName;
 }
@@ -954,8 +882,14 @@ std::string OTRExporter_DisplayList::GetPrefix(ZResource* res)
 	std::string prefix = "";
 	std::string xmlPath = StringHelper::Replace(res->parent->GetXmlFilePath().string(), "\\", "/");
 
-	if (StringHelper::Contains(oName, "_scene") || StringHelper::Contains(oName, "_room"))
+	if (StringHelper::Contains(oName, "_scene") || StringHelper::Contains(oName, "_room")) {
 		prefix = "scenes";
+        if (Globals::Instance->rom->IsMQ()) {
+            prefix += "/mq";
+        } else {
+            prefix += "/nonmq";
+        }
+    }
 	else if (StringHelper::Contains(xmlPath, "objects/"))
 		prefix = "objects";
 	else if (StringHelper::Contains(xmlPath, "textures/"))
@@ -970,4 +904,4 @@ std::string OTRExporter_DisplayList::GetPrefix(ZResource* res)
 		prefix = "code";
 
 	return prefix;
-}
+}

OTRExporter/OTRExporter/Exporter.cpp

@@ -1,15 +1,16 @@
 #include "Exporter.h"
 #include "VersionInfo.h"
 
-void OTRExporter::WriteHeader(ZResource* res, const fs::path& outPath, BinaryWriter* writer, Ship::ResourceType resType)
+void OTRExporter::WriteHeader(ZResource* res, const fs::path& outPath, BinaryWriter* writer, Ship::ResourceType resType, Ship::Version resVersion)
 {
-	writer->Write((uint8_t)Endianess::Little); // 0x00
+	writer->Write((uint8_t)Endianness::Little); // 0x00
 	writer->Write((uint8_t)0); // 0x01
 	writer->Write((uint8_t)0); // 0x02
 	writer->Write((uint8_t)0); // 0x03
 
 	writer->Write((uint32_t)resType); // 0x04
-	writer->Write((uint32_t)MAJOR_VERSION); // 0x08
+	//writer->Write((uint32_t)MAJOR_VERSION); // 0x08
+	writer->Write((uint32_t)resVersion); // 0x08
 	writer->Write((uint64_t)0xDEADBEEFDEADBEEF); // id, 0x0C
 	writer->Write((uint32_t)resourceVersions[resType]); // 0x10
 	writer->Write((uint64_t)0); // ROM CRC, 0x14

OTRExporter/OTRExporter/Exporter.h

@@ -3,10 +3,11 @@
 #include "ZArray.h"
 //#include "OTRExporter.h"
 #include <Utils/BinaryWriter.h>
-#include <Resource.h>
+#include <libultraship/bridge.h>
+#include "VersionInfo.h"
 
 class OTRExporter : public ZResourceExporter
 {
 protected:
-	static void WriteHeader(ZResource* res, const fs::path& outPath, BinaryWriter* writer, Ship::ResourceType resType);
+	static void WriteHeader(ZResource* res, const fs::path& outPath, BinaryWriter* writer, Ship::ResourceType resType, Ship::Version resVersion = MAJOR_VERSION);
 };

OTRExporter/OTRExporter/Main.cpp

@@ -1,4 +1,4 @@
-#include <Archive.h>
+#include "Main.h"
 #include "BackgroundExporter.h"
 #include "TextureExporter.h"
 #include "RoomExporter.h"
@@ -15,16 +15,21 @@
 #include "TextExporter.h"
 #include "BlobExporter.h"
 #include "MtxExporter.h"
+#include "AudioExporter.h"
 #include <Globals.h>
 #include <Utils/File.h>
 #include <Utils/Directory.h>
 #include <Utils/MemoryStream.h>
 #include <Utils/BinaryWriter.h>
+#include <bit>
+#include <mutex>
 
 std::string otrFileName = "oot.otr";
 std::shared_ptr<Ship::Archive> otrArchive;
 BinaryWriter* fileWriter;
 std::chrono::steady_clock::time_point fileStart, resStart;
+std::map<std::string, std::vector<char>> files;
+std::mutex fileMutex;
 
 void InitVersionInfo();
 
@@ -39,21 +44,104 @@ static void ExporterParseFileMode(const std::string& buildMode, ZFileMode& fileM
 	{
 		fileMode = (ZFileMode)ExporterFileMode::BuildOTR;
 
+		printf("BOTR: Generating OTR Archive...\n");
+
 		if (File::Exists(otrFileName))
 			otrArchive = std::shared_ptr<Ship::Archive>(new Ship::Archive(otrFileName, true));
 		else
-			otrArchive = Ship::Archive::CreateArchive(otrFileName, 65536 / 2);
+			otrArchive = Ship::Archive::CreateArchive(otrFileName, 40000);
 
 		auto lst = Directory::ListFiles("Extract");
 
 		for (auto item : lst)
 		{
 			auto fileData = File::ReadAllBytes(item);
-			otrArchive->AddFile(StringHelper::Split(item, "Extract\\")[1], (uintptr_t)fileData.data(), fileData.size());
+			otrArchive->AddFile(StringHelper::Split(item, "Extract/")[1], (uintptr_t)fileData.data(), fileData.size());
 		}
 	}
 }
 
+static void ExporterProgramEnd()
+{
+	if (Globals::Instance->fileMode == ZFileMode::ExtractDirectory)
+	{
+		printf("Creating version file...\n");
+
+		// Get crc from rom
+		std::string romPath = Globals::Instance->baseRomPath.string();
+		std::vector<uint8_t> romData = File::ReadAllBytes(romPath);
+		uint32_t crc = BitConverter::ToUInt32BE(romData, 0x10);
+        uint8_t endianness = (uint8_t)Endianness::Big;
+
+		// Write crc to version file
+		fs::path versionPath("Extract/version");
+        MemoryStream* versionStream = new MemoryStream();
+        BinaryWriter writer(versionStream);
+        writer.SetEndianness(Endianness::Big);
+        writer.Write(endianness);
+        writer.Write(crc);
+		std::ofstream versionFile(versionPath.c_str(), std::ios::out | std::ios::binary);
+        versionFile.write(versionStream->ToVector().data(), versionStream->GetLength());
+		versionFile.flush();
+		versionFile.close();
+        writer.Close();
+
+		printf("Created version file.\n");
+
+		printf("Generating OTR Archive...\n");
+		otrArchive = Ship::Archive::CreateArchive(otrFileName, 40000);
+
+		for (auto item : files) {
+			std::string fName = item.first;
+			if (fName.find("gTitleZeldaShieldLogoMQTex") != std::string::npos && !ZRom(romPath).IsMQ())
+			{
+				size_t pos = 0;
+				if ((pos = fName.find("gTitleZeldaShieldLogoMQTex", 0)) != std::string::npos)
+				{
+					fName.replace(pos, 27, "gTitleZeldaShieldLogoTex");
+				}
+			}
+			auto fileData = item.second;
+			otrArchive->AddFile(fName, (uintptr_t)fileData.data(),
+		                      fileData.size());
+		}
+
+		// Add any additional files that need to be manually copied...
+		auto lst = Directory::ListFiles("Extract");
+
+		for (auto item : lst)
+		{
+			std::vector<std::string> splitPath = StringHelper::Split(item, ".");
+
+			if (splitPath.size() >= 3) {
+				std::string extension = splitPath.at(splitPath.size() - 1);
+				std::string format = splitPath.at(splitPath.size() - 2);
+				splitPath.pop_back();
+				splitPath.pop_back();
+				std::string afterPath = std::accumulate(splitPath.begin(), splitPath.end(), std::string(""));
+				if (extension == "png" && (format == "rgba32" || format == "rgb5a1" || format == "i4" || format == "i8" || format == "ia4" || format == "ia8" || format == "ia16" || format == "ci4" || format == "ci8")) {
+					Globals::Instance->buildRawTexture = true;
+					Globals::Instance->BuildAssetTexture(item, ZTexture::GetTextureTypeFromString(format), afterPath);
+					Globals::Instance->buildRawTexture = false;
+
+					auto fileData = File::ReadAllBytes(afterPath);
+					printf("otrArchive->AddFile(%s)\n", StringHelper::Split(afterPath, "Extract/")[1].c_str());
+					otrArchive->AddFile(StringHelper::Split(afterPath, "Extract/")[1], (uintptr_t)fileData.data(), fileData.size());
+				}
+			}
+
+			auto fileData = File::ReadAllBytes(item);
+			printf("otrArchive->AddFile(%s)\n", StringHelper::Split(item, "Extract/")[1].c_str());
+			otrArchive->AddFile(StringHelper::Split(item, "Extract/")[1], (uintptr_t)fileData.data(), fileData.size());
+		}
+
+		//otrArchive->AddFile("Audiobank", (uintptr_t)Globals::Instance->GetBaseromFile("Audiobank").data(), Globals::Instance->GetBaseromFile("Audiobank").size());
+		//otrArchive->AddFile("Audioseq", (uintptr_t)Globals::Instance->GetBaseromFile("Audioseq").data(), Globals::Instance->GetBaseromFile("Audioseq").size());
+		//otrArchive->AddFile("Audiotable", (uintptr_t)Globals::Instance->GetBaseromFile("Audiotable").data(), Globals::Instance->GetBaseromFile("Audiotable").size());
+	}
+}
+
+
 static void ExporterParseArgs(int argc, char* argv[], int& i)
 {
 	std::string arg = argv[i];
@@ -85,6 +173,7 @@ static void ExporterFileBegin(ZFile* file)
 
 static void ExporterFileEnd(ZFile* file)
 {
+	// delete fileWriter;
 }
 
 static void ExporterResourceEnd(ZResource* res, BinaryWriter& writer)
@@ -107,7 +196,7 @@ static void ExporterResourceEnd(ZResource* res, BinaryWriter& writer)
 		{
 			auto split = StringHelper::Split(oName, "_");
 			oName = "";
-			for (int i = 0; i < split.size() - 1; i++)
+			for (size_t i = 0; i < split.size() - 1; i++)
 				oName += split[i] + "_";
 
 			oName += "scene";
@@ -120,11 +209,17 @@ static void ExporterResourceEnd(ZResource* res, BinaryWriter& writer)
 		std::string fName = "";
 
 		if (prefix != "")
-			fName = StringHelper::Sprintf("%s\\%s\\%s", prefix.c_str(), oName.c_str(), rName.c_str());
+			fName = StringHelper::Sprintf("%s/%s/%s", prefix.c_str(), oName.c_str(), rName.c_str());
 		else
-			fName = StringHelper::Sprintf("%s\\%s", oName.c_str(), rName.c_str());
+			fName = StringHelper::Sprintf("%s/%s", oName.c_str(), rName.c_str());
 
-		File::WriteAllBytes("Extract\\" + fName, strem->ToVector());
+		if (Globals::Instance->fileMode == ZFileMode::ExtractDirectory)
+		{
+			std::unique_lock Lock(fileMutex);
+			files[fName] = strem->ToVector();
+		}
+		else
+			File::WriteAllBytes("Extract/" + fName, strem->ToVector());
 	}
 
 	auto end = std::chrono::steady_clock::now();
@@ -142,6 +237,17 @@ static void ExporterXMLEnd()
 {
 }
 
+void AddFile(std::string fName, std::vector<char> data)
+{
+	if (Globals::Instance->fileMode != ZFileMode::ExtractDirectory)
+		File::WriteAllBytes("Extract/" + fName, data);
+	else
+	{
+		std::unique_lock Lock(fileMutex);
+		files[fName] = data;
+	}
+}
+
 static void ImportExporters()
 {
 	// In this example we set up a new exporter called "EXAMPLE".
@@ -155,6 +261,8 @@ static void ImportExporters()
 	exporterSet->beginXMLFunc = ExporterXMLBegin;
 	exporterSet->endXMLFunc = ExporterXMLEnd;
 	exporterSet->resSaveFunc = ExporterResourceEnd;
+	exporterSet->endProgramFunc = ExporterProgramEnd;
+
 	exporterSet->exporters[ZResourceType::Background] = new OTRExporter_Background();
 	exporterSet->exporters[ZResourceType::Texture] = new OTRExporter_Texture();
 	exporterSet->exporters[ZResourceType::Room] = new OTRExporter_Room();
@@ -173,6 +281,7 @@ static void ImportExporters()
 	exporterSet->exporters[ZResourceType::Text] = new OTRExporter_Text();
 	exporterSet->exporters[ZResourceType::Blob] = new OTRExporter_Blob();
 	exporterSet->exporters[ZResourceType::Mtx] = new OTRExporter_MtxExporter();
+	exporterSet->exporters[ZResourceType::Audio] = new OTRExporter_Audio();
 
 	Globals::AddExporter("OTR", exporterSet);
 

OTRExporter/OTRExporter/Main.h

@@ -1,5 +1,8 @@
 #pragma once
 
-#include <Archive.h>
+#include <libultraship/bridge.h>
 
-extern std::shared_ptr<Ship::Archive> otrArchive;
+extern std::shared_ptr<Ship::Archive> otrArchive;
+extern std::map<std::string, std::vector<char>> files;
+
+void AddFile(std::string fName, std::vector<char> data);

OTRExporter/OTRExporter/Makefile

@@ -1,70 +0,0 @@
-# Only used for standalone compilation, usually inherits these from the main makefile
-
-CXX := g++
-AR	:= ar
-FORMAT := clang-format-11
-
-ASAN ?= 0
-DEBUG ?= 1
-OPTFLAGS ?= -O0
-LTO ?= 0
-
-WARN := -Wall -Wextra -Werror \
-	-Wno-unused-parameter \
-	-Wno-unused-function \
-	-Wno-unused-variable
-
-
-CXXFLAGS := $(WARN) -std=c++17 
-CPPFLAGS := -MMD
-
-ifneq ($(DEBUG),0)
-	CXXFLAGS += -g
-endif
-
-ifneq ($(ASAN),0)
-	CXXFLAGS += -fsanitize=address
-endif
-
-ifneq ($(LTO),0)
-	CXXFLAGS += -flto
-endif
-
-SRC_DIRS  := $(shell find -type d -not -path "*build*")
-CXX_FILES := $(foreach dir,$(SRC_DIRS),$(wildcard $(dir)/*.cpp))
-H_FILES   := $(foreach dir,$(SRC_DIRS),$(wildcard $(dir)/*.h))
-
-O_FILES   := $(CXX_FILES:%.cpp=build/%.o)
-D_FILES   := $(O_FILES:%.o=%.d)
-LIB       := OTRExporter.a
-
-INC_DIRS := $(addprefix -I, \
-	../../ZAPD/ZAPD \
-	../../ZAPD/lib/tinyxml2 \
-	../../ZAPD/lib/libgfxd \
-	../../ZAPD/ZAPDUtils \
-	../../OtrLib/otrlib \
-	../../OtrLib/otrlib/Lib/spdlog/include \
-	../../OtrLib/otrlib/Lib/Fast3D/U64 \
-)
-
-# create build directories
-$(shell mkdir -p $(SRC_DIRS:%=build/%))
-
-all: $(LIB)
-
-clean:
-	rm -rf build $(LIB)
-
-format:
-	$(FORMAT) -i $(CXX_FILES) $(H_FILES)
-
-.PHONY: all clean format
-
-build/%.o: %.cpp
-	$(CXX) $(CXXFLAGS) $(CPPFLAGS) $(OPTFLAGS) $(INC_DIRS) -c $< -o $@
-
-$(LIB): $(O_FILES)
-	$(AR) rcs $@ $^
-
--include $(D_FILES)

OTRExporter/OTRExporter/OTRExporter.vcxproj

@@ -1,202 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Debug|x64">
-      <Configuration>Debug</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|x64">
-      <Configuration>Release</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="ArrayExporter.h" />
-    <ClInclude Include="BackgroundExporter.h" />
-    <ClInclude Include="BlobExporter.h" />
-    <ClInclude Include="CollisionExporter.h" />
-    <ClInclude Include="command_macros_base.h" />
-    <ClInclude Include="CutsceneExporter.h" />
-    <ClInclude Include="DisplayListExporter.h" />
-    <ClInclude Include="AnimationExporter.h" />
-    <ClInclude Include="Main.h" />
-    <ClInclude Include="Exporter.h" />
-    <ClInclude Include="MtxExporter.h" />
-    <ClInclude Include="SkeletonExporter.h" />
-    <ClInclude Include="SkeletonLimbExporter.h" />
-    <ClInclude Include="PathExporter.h" />
-    <ClInclude Include="PlayerAnimationExporter.h" />
-    <ClInclude Include="RoomExporter.h" />
-    <ClInclude Include="TextExporter.h" />
-    <ClInclude Include="TextureExporter.h" />
-    <ClInclude Include="VersionInfo.h" />
-    <ClInclude Include="VtxExporter.h" />
-    <ClInclude Include="z64cutscene.h" />
-    <ClInclude Include="z64cutscene_commands.h" />
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="ArrayExporter.cpp" />
-    <ClCompile Include="BackgroundExporter.cpp" />
-    <ClCompile Include="BlobExporter.cpp" />
-    <ClCompile Include="CollisionExporter.cpp" />
-    <ClCompile Include="CutsceneExporter.cpp" />
-    <ClCompile Include="DisplayListExporter.cpp" />
-    <ClCompile Include="AnimationExporter.cpp" />
-    <ClCompile Include="Main.cpp" />
-    <ClCompile Include="Exporter.cpp" />
-    <ClCompile Include="MtxExporter.cpp" />
-    <ClCompile Include="SkeletonExporter.cpp" />
-    <ClCompile Include="SkeletonLimbExporter.cpp" />
-    <ClCompile Include="PathExporter.cpp" />
-    <ClCompile Include="PlayerAnimationExporter.cpp" />
-    <ClCompile Include="RoomExporter.cpp" />
-    <ClCompile Include="TextExporter.cpp" />
-    <ClCompile Include="TextureExporter.cpp" />
-    <ClCompile Include="VersionInfo.cpp" />
-    <ClCompile Include="VtxExporter.cpp" />
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <VCProjectVersion>16.0</VCProjectVersion>
-    <Keyword>Win32Proj</Keyword>
-    <ProjectGuid>{a6103fd3-0709-4fc7-b066-1a6e056d6306}</ProjectGuid>
-    <RootNamespace>OTRExporter</RootNamespace>
-    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>StaticLibrary</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v142</PlatformToolset>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v142</PlatformToolset>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
-    <ConfigurationType>StaticLibrary</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v142</PlatformToolset>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
-    <ConfigurationType>StaticLibrary</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v142</PlatformToolset>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Label="Shared">
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <LinkIncremental>true</LinkIncremental>
-    <IncludePath>$(SolutionDir)otrlib;$(SolutionDir)\ZAPD\ZAPD\;$(SolutionDir)\ZAPD\lib\tinyxml2;$(SolutionDir)\ZAPD\lib\libgfxd;$(SolutionDir)\ZAPD\lib\elfio;$(SolutionDir)\ZAPD\lib\assimp\include;$(SolutionDir)\ZAPD\lib\stb;$(ProjectDir);$(IncludePath)</IncludePath>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <LinkIncremental>false</LinkIncremental>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <LinkIncremental>true</LinkIncremental>
-    <IncludePath>$(ProjectDir)..\..\ZAPDTR\ZAPD;$(ProjectDir)..\..\ZAPDTR\lib\tinyxml2;$(ProjectDir)..\..\ZAPDTR\lib\libgfxd;$(ProjectDir)..\..\ZAPDTR\ZAPDUtils;$(ProjectDir)..\..\libultraship\libultraship;$(ProjectDir)..\..\libultraship\libultraship\lib\spdlog\include;$(ProjectDir)..\..\libultraship\libultraship\Lib\Fast3D\U64;$(IncludePath)</IncludePath>
-    <LibraryPath>$(ProjectDir)..\..\libultraship\libultraship;$(LibraryPath)</LibraryPath>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <LinkIncremental>false</LinkIncremental>
-    <IncludePath>$(ProjectDir)..\..\ZAPDTR\ZAPD;$(ProjectDir)..\..\ZAPDTR\lib\tinyxml2;$(ProjectDir)..\..\ZAPDTR\lib\libgfxd;$(ProjectDir)..\..\ZAPDTR\ZAPDUtils;$(ProjectDir)..\..\libultraship\libultraship;$(ProjectDir)..\..\libultraship\libultraship\lib\spdlog\include;$(ProjectDir)..\..\libultraship\libultraship\Lib\Fast3D\U64;$(IncludePath)</IncludePath>
-    <LibraryPath>$(ProjectDir)..\..\libultraship\libultraship;$(LibraryPath)</LibraryPath>
-  </PropertyGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <ConformanceMode>true</ConformanceMode>
-      <LanguageStandard>stdcpp17</LanguageStandard>
-    </ClCompile>
-    <Link>
-      <SubSystem>Console</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <ConformanceMode>true</ConformanceMode>
-    </ClCompile>
-    <Link>
-      <SubSystem>Console</SubSystem>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <OptimizeReferences>true</OptimizeReferences>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>_DEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <ConformanceMode>true</ConformanceMode>
-      <LanguageStandard>stdcpp17</LanguageStandard>
-      <LanguageStandard_C>stdc11</LanguageStandard_C>
-      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
-    </ClCompile>
-    <Link>
-      <SubSystem>Console</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <AdditionalDependencies>ZAPDUtils.lib;OTRLib.lib;%(AdditionalDependencies)</AdditionalDependencies>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>NDEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <ConformanceMode>true</ConformanceMode>
-      <LanguageStandard>stdcpp17</LanguageStandard>
-      <LanguageStandard_C>stdc11</LanguageStandard_C>
-      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
-    </ClCompile>
-    <Link>
-      <SubSystem>Console</SubSystem>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <OptimizeReferences>true</OptimizeReferences>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-    </Link>
-  </ItemDefinitionGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
-</Project>

OTRExporter/OTRExporter/OTRExporter.vcxproj.filters

@@ -1,144 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup>
-    <Filter Include="Source Files">
-      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
-      <Extensions>cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
-    </Filter>
-    <Filter Include="Header Files">
-      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
-      <Extensions>h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd</Extensions>
-    </Filter>
-    <Filter Include="Resource Files">
-      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
-      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="CollisionExporter.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="RoomExporter.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="TextureExporter.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="DisplayListExporter.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="Main.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="PlayerAnimationExporter.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="BackgroundExporter.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="VtxExporter.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="ArrayExporter.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="Exporter.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="AnimationExporter.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="CutsceneExporter.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="z64cutscene.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="z64cutscene_commands.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="command_macros_base.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="PathExporter.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="SkeletonExporter.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="SkeletonLimbExporter.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="TextExporter.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="BlobExporter.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="MtxExporter.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="VersionInfo.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="CollisionExporter.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="Main.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="RoomExporter.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="TextureExporter.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="DisplayListExporter.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="PlayerAnimationExporter.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="SkeletonExporter.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="SkeletonLimbExporter.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="BackgroundExporter.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="VtxExporter.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="ArrayExporter.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="Exporter.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="AnimationExporter.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="CutsceneExporter.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="PathExporter.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="TextExporter.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="BlobExporter.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="MtxExporter.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="VersionInfo.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-  </ItemGroup>
-</Project>

OTRExporter/OTRExporter/PathExporter.cpp

@@ -5,15 +5,15 @@ void OTRExporter_Path::Save(ZResource* res, const fs::path& outPath, BinaryWrite
 {
 	ZPath* path = (ZPath*)res;
 
-	WriteHeader(res, outPath, writer, Ship::ResourceType::Path);
+	WriteHeader(res, outPath, writer, Ship::ResourceType::SOH_Path);
 	
 	writer->Write((uint32_t)path->pathways.size());
 
-	for (int k = 0; k < path->pathways.size(); k++)
+	for (size_t k = 0; k < path->pathways.size(); k++)
 	{
 		writer->Write((uint32_t)path->pathways[k].points.size());
 
-		for (int i = 0; i < path->pathways[k].points.size(); i++)
+		for (size_t i = 0; i < path->pathways[k].points.size(); i++)
 		{
 			writer->Write(path->pathways[k].points[i].scalars[0].scalarData.s16);
 			writer->Write(path->pathways[k].points[i].scalars[1].scalarData.s16);

OTRExporter/OTRExporter/PlayerAnimationExporter.cpp

@@ -1,11 +1,11 @@
 #include "PlayerAnimationExporter.h"
-#include <Resource.h>
+#include <libultraship/bridge.h>
 
 void OTRExporter_PlayerAnimationExporter::Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer)
 {
 	ZPlayerAnimationData* anim = (ZPlayerAnimationData*)res;
 
-	WriteHeader(res, outPath, writer, Ship::ResourceType::PlayerAnimation);
+	WriteHeader(res, outPath, writer, Ship::ResourceType::SOH_PlayerAnimation);
 
 	auto start = std::chrono::steady_clock::now();
 	

OTRExporter/OTRExporter/RoomExporter.cpp

@@ -23,7 +23,7 @@
 #include <ZRoom/Commands/SetAlternateHeaders.h>
 #include "CollisionExporter.h"
 #include "DisplayListExporter.h"
-#include "Resource.h"
+#include <libultraship/bridge.h>
 #include <Globals.h>
 #include <ZRoom/Commands/SetExitList.h>
 #include <ZRoom/Commands/SetPathways.h>
@@ -39,14 +39,14 @@ void OTRExporter_Room::Save(ZResource* res, const fs::path& outPath, BinaryWrite
 {
 	ZRoom* room = (ZRoom*)res;
 
-	WriteHeader(res, outPath, writer, Ship::ResourceType::Room);
+	WriteHeader(res, outPath, writer, Ship::ResourceType::SOH_Room);
 
 	writer->Write((uint32_t)room->commands.size());
 
 	for (size_t i = 0; i < room->commands.size(); i++)
 	{
 		ZRoomCommand* cmd = room->commands[i];
-				
+
 		writer->Write((uint32_t)cmd->cmdID);
 
 		switch (cmd->cmdID)
@@ -172,7 +172,7 @@ void OTRExporter_Room::Save(ZResource* res, const fs::path& outPath, BinaryWrite
 
 			writer->Write((uint32_t)cmdCsCam->points.size());
 
-			for (int i = 0; i < cmdCsCam->points.size(); i++)
+			for (size_t i = 0; i < cmdCsCam->points.size(); i++)
 			{
 				writer->Write(cmdCsCam->points[i].scalars[0].scalarData.s16);
 				writer->Write(cmdCsCam->points[i].scalars[1].scalarData.s16);
@@ -183,7 +183,7 @@ void OTRExporter_Room::Save(ZResource* res, const fs::path& outPath, BinaryWrite
 		case RoomCommand::SetMesh:
 		{
 			SetMesh* cmdMesh = (SetMesh*)cmd;
-			
+
 			writer->Write((uint8_t)cmdMesh->data); // 0x01
 			writer->Write(cmdMesh->meshHeaderType);
 
@@ -207,12 +207,12 @@ void OTRExporter_Room::Save(ZResource* res, const fs::path& outPath, BinaryWrite
 				Declaration* dListDeclXlu = poly->parent->GetDeclaration(GETSEGOFFSET(test->xlu));
 
 				if (test->opa != 0)
-					writer->Write(StringHelper::Sprintf("%s\\%s", OTRExporter_DisplayList::GetParentFolderName(res).c_str(), dListDeclOpa->varName.c_str()));
+					writer->Write(StringHelper::Sprintf("%s/%s", OTRExporter_DisplayList::GetParentFolderName(res).c_str(), dListDeclOpa->varName.c_str()));
 				else
 					writer->Write("");
-				
+
 				if (test->xlu != 0)
-					writer->Write(StringHelper::Sprintf("%s\\%s", OTRExporter_DisplayList::GetParentFolderName(res).c_str(), dListDeclXlu->varName.c_str()));
+					writer->Write(StringHelper::Sprintf("%s/%s", OTRExporter_DisplayList::GetParentFolderName(res).c_str(), dListDeclXlu->varName.c_str()));
 				else
 					writer->Write("");
 
@@ -228,7 +228,7 @@ void OTRExporter_Room::Save(ZResource* res, const fs::path& outPath, BinaryWrite
 						Declaration* bgDecl = poly->parent->GetDeclarationRanged(GETSEGOFFSET(poly->multiList[i].source));
 
 						writer->Write(OTRExporter_DisplayList::GetPathToRes(poly->multiList[i].sourceBackground, bgDecl->varName));
-						
+
 						writer->Write(poly->multiList[i].unk_0C);
 						writer->Write(poly->multiList[i].tlut);
 						writer->Write(poly->multiList[i].width);
@@ -338,7 +338,7 @@ void OTRExporter_Room::Save(ZResource* res, const fs::path& outPath, BinaryWrite
 
 			for (size_t i = 0;i < cmdRoom->romfile->numRooms; i++)
 			{
-				//std::string roomName = StringHelper::Sprintf("%s\\%s_room_%i", (StringHelper::Split(room->GetName(), "_")[0] + "_scene").c_str(), StringHelper::Split(room->GetName(), "_scene")[0].c_str(), i);
+				//std::string roomName = StringHelper::Sprintf("%s/%s_room_%i", (StringHelper::Split(room->GetName(), "_")[0] + "_scene").c_str(), StringHelper::Split(room->GetName(), "_scene")[0].c_str(), i);
 				std::string roomName = OTRExporter_DisplayList::GetPathToRes(room, StringHelper::Sprintf("%s_room_%i", StringHelper::Split(room->GetName(), "_scene")[0].c_str(), i));
 				writer->Write(roomName);
 				writer->Write(cmdRoom->romfile->rooms[i].virtualAddressStart);
@@ -383,7 +383,7 @@ void OTRExporter_Room::Save(ZResource* res, const fs::path& outPath, BinaryWrite
 			uint32_t baseStreamEnd = writer->GetStream().get()->GetLength();
 
 			writer->Write((uint32_t)cmdStartPos->actors.size()); // 0x01
-			
+
 			for (const ActorSpawnEntry& entry : cmdStartPos->actors)
 			{
 				writer->Write(entry.actorNum);
@@ -407,7 +407,7 @@ void OTRExporter_Room::Save(ZResource* res, const fs::path& outPath, BinaryWrite
 			{
 				uint32_t seg = cmdHeaders->headers[i] & 0xFFFFFFFF;
 				std::string headerName = "";
-				bool foundDecl = Globals::Instance->GetSegmentedPtrName(seg, room->parent, "", headerName);
+				bool foundDecl = Globals::Instance->GetSegmentedPtrName(seg, room->parent, "", headerName, res->parent->workerID);
 				if (headerName == "NULL")
 					writer->Write("");
 				else
@@ -441,9 +441,9 @@ void OTRExporter_Room::Save(ZResource* res, const fs::path& outPath, BinaryWrite
 		case RoomCommand::SetCutscenes:
 		{
 			SetCutscenes* cmdSetCutscenes = (SetCutscenes*)cmd;
-			
+
 			std::string listName;
-			Globals::Instance->GetSegmentedPtrName(cmdSetCutscenes->cmdArg2, room->parent, "CutsceneData", listName);
+			Globals::Instance->GetSegmentedPtrName(cmdSetCutscenes->cmdArg2, room->parent, "CutsceneData", listName, res->parent->workerID);
 			std::string fName = OTRExporter_DisplayList::GetPathToRes(room, listName);
 			//std::string fName = StringHelper::Sprintf("%s\\%s", OTRExporter_DisplayList::GetParentFolderName(room).c_str(), listName.c_str());
 			writer->Write(fName);
@@ -453,10 +453,7 @@ void OTRExporter_Room::Save(ZResource* res, const fs::path& outPath, BinaryWrite
 			OTRExporter_Cutscene cs;
 			cs.Save(cmdSetCutscenes->cutscenes[0], "", &csWriter);
 
-			File::WriteAllBytes("Extract\\" + fName, csStream->ToVector());
-
-			//std::string fName = OTRExporter_DisplayList::GetPathToRes(res, vtxDecl->varName);
-			//otrArchive->AddFile(fName, (uintptr_t)csStream->ToVector().data(), csWriter.GetBaseAddress());
+			AddFile(fName, csStream->ToVector());
 		}
 			break;
 		case RoomCommand::SetPathways:
@@ -465,7 +462,7 @@ void OTRExporter_Room::Save(ZResource* res, const fs::path& outPath, BinaryWrite
 
 			writer->Write((uint32_t)cmdSetPathways->pathwayList.pathways.size());
 
-			for (int i = 0; i < cmdSetPathways->pathwayList.pathways.size(); i++)
+			for (size_t i = 0; i < cmdSetPathways->pathwayList.pathways.size(); i++)
 			{
 				Declaration* decl = room->parent->GetDeclaration(GETSEGOFFSET(cmdSetPathways->pathwayList.pathways[i].listSegmentAddress));
 				//std::string path = StringHelper::Sprintf("%s\\%s", OTRExporter_DisplayList::GetParentFolderName(res).c_str(), decl->varName.c_str());
@@ -477,11 +474,7 @@ void OTRExporter_Room::Save(ZResource* res, const fs::path& outPath, BinaryWrite
 				OTRExporter_Path pathExp;
 				pathExp.Save(&cmdSetPathways->pathwayList, outPath, &pathWriter);
 
-				File::WriteAllBytes("Extract\\" + path, pathStream->ToVector());
-
-				//otrArchive->AddFile(path, (uintptr_t)pathStream->ToVector().data(), pathWriter.GetBaseAddress());
-
-				int bp = 0;
+				AddFile(path, pathStream->ToVector());
 			}
 		}
 			break;
@@ -508,12 +501,12 @@ void OTRExporter_Room::WritePolyDList(BinaryWriter* writer, ZRoom* room, Polygon
 		writer->Write(dlist->unk_06);
 		[[fallthrough]];
 	default:
-		//writer->Write(StringHelper::Sprintf("%s\\%s", OTRExporter_DisplayList::GetParentFolderName(res).c_str(), dListDeclOpa->varName.c_str()));
+		//writer->Write(StringHelper::Sprintf("%s/%s", OTRExporter_DisplayList::GetParentFolderName(res).c_str(), dListDeclOpa->varName.c_str()));
 
 		if (dlist->opaDList != nullptr)
 		{
 			auto opaDecl = room->parent->GetDeclaration(GETSEGOFFSET(dlist->opaDList->GetRawDataIndex()));
-			writer->Write(StringHelper::Sprintf("%s\\%s", OTRExporter_DisplayList::GetParentFolderName(room).c_str(), opaDecl->varName.c_str()));
+			writer->Write(StringHelper::Sprintf("%s/%s", OTRExporter_DisplayList::GetParentFolderName(room).c_str(), opaDecl->varName.c_str()));
 		}
 		else
 			writer->Write("");
@@ -521,7 +514,7 @@ void OTRExporter_Room::WritePolyDList(BinaryWriter* writer, ZRoom* room, Polygon
 		if (dlist->xluDList != nullptr)
 		{
 			auto xluDecl = room->parent->GetDeclaration(GETSEGOFFSET(dlist->xluDList->GetRawDataIndex()));
-			writer->Write(StringHelper::Sprintf("%s\\%s", OTRExporter_DisplayList::GetParentFolderName(room).c_str(), xluDecl->varName.c_str()));
+			writer->Write(StringHelper::Sprintf("%s/%s", OTRExporter_DisplayList::GetParentFolderName(room).c_str(), xluDecl->varName.c_str()));
 		}
 		else
 			writer->Write("");

OTRExporter/OTRExporter/SkeletonExporter.cpp

@@ -1,5 +1,5 @@
 #include "SkeletonExporter.h"
-#include <Resource.h>
+#include <libultraship/bridge.h>
 #include <Globals.h>
 #include "DisplayListExporter.h"
 
@@ -7,7 +7,7 @@ void OTRExporter_Skeleton::Save(ZResource* res, const fs::path& outPath, BinaryW
 {
 	ZSkeleton* skel = (ZSkeleton*)res;
 
-	WriteHeader(res, outPath, writer, Ship::ResourceType::Skeleton);
+	WriteHeader(res, outPath, writer, Ship::ResourceType::SOH_Skeleton);
 
 	writer->Write((uint8_t)skel->type);
 	writer->Write((uint8_t)skel->limbType);
@@ -23,7 +23,7 @@ void OTRExporter_Skeleton::Save(ZResource* res, const fs::path& outPath, BinaryW
 		Declaration* skelDecl = skel->parent->GetDeclarationRanged(GETSEGOFFSET(skel->limbsTable.limbsAddresses[i]));
 
 		std::string name;
-		bool foundDecl = Globals::Instance->GetSegmentedPtrName(skel->limbsTable.limbsAddresses[i], skel->parent, "", name);
+		bool foundDecl = Globals::Instance->GetSegmentedPtrName(skel->limbsTable.limbsAddresses[i], skel->parent, "", name, res->parent->workerID);
 		if (foundDecl)
 		{
 			if (name.at(0) == '&')

OTRExporter/OTRExporter/SkeletonLimbExporter.cpp

@@ -1,13 +1,13 @@
 #include "SkeletonLimbExporter.h"
 #include "DisplayListExporter.h"
-#include <Resource.h>
+#include <libultraship/bridge.h>
 #include <Globals.h>
 
 void OTRExporter_SkeletonLimb::Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer)
 {
 	ZLimb* limb = (ZLimb*)res;
 
-	WriteHeader(res, outPath, writer, Ship::ResourceType::SkeletonLimb);
+	WriteHeader(res, outPath, writer, Ship::ResourceType::SOH_SkeletonLimb);
 
 	writer->Write((uint8_t)limb->type);
 	writer->Write((uint8_t)limb->skinSegmentType);
@@ -86,7 +86,7 @@ void OTRExporter_SkeletonLimb::Save(ZResource* res, const fs::path& outPath, Bin
 	if (limb->childPtr != 0)
 	{
 		std::string name;
-		bool foundDecl = Globals::Instance->GetSegmentedPtrName(limb->childPtr, limb->parent, "", name);
+		bool foundDecl = Globals::Instance->GetSegmentedPtrName(limb->childPtr, limb->parent, "", name, res->parent->workerID);
 		if (foundDecl)
 		{
 			if (name.at(0) == '&')
@@ -107,7 +107,7 @@ void OTRExporter_SkeletonLimb::Save(ZResource* res, const fs::path& outPath, Bin
 	if (limb->siblingPtr != 0)
 	{
 		std::string name;
-		bool foundDecl = Globals::Instance->GetSegmentedPtrName(limb->siblingPtr, limb->parent, "", name);
+		bool foundDecl = Globals::Instance->GetSegmentedPtrName(limb->siblingPtr, limb->parent, "", name, res->parent->workerID);
 		if (foundDecl)
 		{
 			if (name.at(0) == '&')
@@ -128,7 +128,7 @@ void OTRExporter_SkeletonLimb::Save(ZResource* res, const fs::path& outPath, Bin
 	if (limb->dListPtr != 0)
 	{
 		std::string name;
-		bool foundDecl = Globals::Instance->GetSegmentedPtrName(limb->dListPtr, limb->parent, "", name);
+		bool foundDecl = Globals::Instance->GetSegmentedPtrName(limb->dListPtr, limb->parent, "", name, res->parent->workerID);
 		if (foundDecl)
 		{
 			if (name.at(0) == '&')
@@ -149,7 +149,7 @@ void OTRExporter_SkeletonLimb::Save(ZResource* res, const fs::path& outPath, Bin
 	if (limb->dList2Ptr != 0)
 	{
 		std::string name;
-		bool foundDecl = Globals::Instance->GetSegmentedPtrName(limb->dList2Ptr, limb->parent, "", name);
+		bool foundDecl = Globals::Instance->GetSegmentedPtrName(limb->dList2Ptr, limb->parent, "", name, res->parent->workerID);
 		if (foundDecl)
 		{
 			if (name.at(0) == '&')

OTRExporter/OTRExporter/TextExporter.cpp

@@ -5,11 +5,11 @@ void OTRExporter_Text::Save(ZResource* res, const fs::path& outPath, BinaryWrite
 {
 	ZText* txt = (ZText*)res;
 
-	WriteHeader(txt, outPath, writer, Ship::ResourceType::Text);
+	WriteHeader(txt, outPath, writer, Ship::ResourceType::SOH_Text);
 
 	writer->Write((uint32_t)txt->messages.size());
-	
-	for (int i = 0; i < txt->messages.size(); i++)
+
+	for (size_t i = 0; i < txt->messages.size(); i++)
 	{
 		writer->Write(txt->messages[i].id);
 		writer->Write(txt->messages[i].textboxType);

OTRExporter/OTRExporter/VersionInfo.cpp

@@ -1,25 +1,25 @@
 #include "VersionInfo.h"
-#include <Resource.h>
+#include <libultraship/bridge.h>
 
 std::map<Ship::ResourceType, uint32_t> resourceVersions;
 
 void InitVersionInfo()
 {
-	resourceVersions[Ship::ResourceType::Animation] = 0;
-	resourceVersions[Ship::ResourceType::Model] = 0;
-	resourceVersions[Ship::ResourceType::Texture] = 0;
-	resourceVersions[Ship::ResourceType::Material] = 0;
-	resourceVersions[Ship::ResourceType::PlayerAnimation] = 0;
-	resourceVersions[Ship::ResourceType::DisplayList] = 0;
-	resourceVersions[Ship::ResourceType::Room] = 0;
-	resourceVersions[Ship::ResourceType::CollisionHeader] = 0;
-	resourceVersions[Ship::ResourceType::Skeleton] = 0;
-	resourceVersions[Ship::ResourceType::SkeletonLimb] = 0;
-	resourceVersions[Ship::ResourceType::Matrix] = 0;
-	resourceVersions[Ship::ResourceType::Path] = 0;
-	resourceVersions[Ship::ResourceType::Vertex] = 0;
-	resourceVersions[Ship::ResourceType::Cutscene] = 0;
-	resourceVersions[Ship::ResourceType::Array] = 0;
-	resourceVersions[Ship::ResourceType::Text] = 0;
-	resourceVersions[Ship::ResourceType::Blob] = 0;
-}
+	resourceVersions = std::map<Ship::ResourceType, uint32_t> {
+	{ Ship::ResourceType::SOH_Animation, 0 },
+	{ Ship::ResourceType::Texture, 0 },
+	{ Ship::ResourceType::SOH_PlayerAnimation, 0 },
+	{ Ship::ResourceType::DisplayList, 0 },
+	{ Ship::ResourceType::SOH_Room, 0 },
+	{ Ship::ResourceType::SOH_CollisionHeader, 0 },
+	{ Ship::ResourceType::SOH_Skeleton, 0 },
+	{ Ship::ResourceType::SOH_SkeletonLimb, 0 },
+	{ Ship::ResourceType::Matrix, 0 },
+	{ Ship::ResourceType::SOH_Path, 0 },
+	{ Ship::ResourceType::Vertex, 0 },
+	{ Ship::ResourceType::SOH_Cutscene, 0 },
+	{ Ship::ResourceType::Array, 0 },
+	{ Ship::ResourceType::SOH_Text, 0 },
+	{ Ship::ResourceType::Blob, 0 },
+	};
+}

OTRExporter/OTRExporter/VersionInfo.h

@@ -2,7 +2,7 @@
 
 #include <map>
 #include <vector>
-#include "Resource.h"
+#include "src/resource/Resource.h"
 
 #define MAJOR_VERSION Ship::Version::Deckard
 

OTRExporter/OTRExporter/VtxExporter.cpp

@@ -1,5 +1,5 @@
 #include "VtxExporter.h"
-#include "Resource.h"
+#include <libultraship/bridge.h>
 #include "VersionInfo.h"
 
 

OTRExporter/OTRExporter/z64cutscene.h

@@ -2,7 +2,7 @@
 #define Z64CUTSCENE_H
 
 #if 0
-#include "ultra64.h"
+#include <libultraship/libultra.h>
 
 typedef struct {
     /* 0x00 */ u16 entrance;       // entrance index upon which the cutscene should trigger

OTRExporter/extract_assets.py

@@ -1,117 +1,47 @@
 #!/usr/bin/env python3
 
-import argparse, json, os, signal, time, sys, shutil
-from multiprocessing import Pool, cpu_count, Event, Manager, ProcessError
+import os, sys, shutil
 import shutil
+from rom_info import Z64Rom
+import rom_chooser
+import struct
+import subprocess
+import argparse
 
-def SignalHandler(sig, frame):
-    print(f'Signal {sig} received. Aborting...')
-    mainAbort.set()
-    # Don't exit immediately to update the extracted assets file.
-
-def BuildOTR():
-    shutil.copyfile("baserom/Audiobank", "Extract/Audiobank")
-    shutil.copyfile("baserom/Audioseq", "Extract/Audioseq")
-    shutil.copyfile("baserom/Audiotable", "Extract/Audiotable")
-
+def BuildOTR(xmlPath, rom, zapd_exe=None):
     shutil.copytree("assets", "Extract/assets")
 
-    execStr = "x64\\Release\\ZAPD.exe" if sys.platform == "win32" else "../ZAPD/ZAPD.out"
+    if not zapd_exe:
+        zapd_exe = "x64\\Release\\ZAPD.exe" if sys.platform == "win32" else "../ZAPDTR/ZAPD.out"
 
-    execStr += " botr -se OTR"
+    exec_cmd = [zapd_exe, "ed", "-i", xmlPath, "-b", rom, "-fl", "CFG/filelists",
+            "-o", "placeholder", "-osf", "placeholder", "-gsf", "1",
+            "-rconf", "CFG/Config.xml", "-se", "OTR", "--otrfile", 
+            "oot-mq.otr" if Z64Rom.isMqRom(rom) else "oot.otr"]
 
-    print(execStr)
-    exitValue = os.system(execStr)
+    print(exec_cmd)
+    exitValue = subprocess.call(exec_cmd)
     if exitValue != 0:
         print("\n")
         print("Error when building the OTR file...", file=os.sys.stderr)
         print("Aborting...", file=os.sys.stderr)
         print("\n")
 
-def ExtractFile(xmlPath, outputPath, outputSourcePath):
-    execStr = "x64\\Release\\ZAPD.exe" if sys.platform == "win32" else "../ZAPD/ZAPD.out"
-    execStr += " e -eh -i %s -b baserom/ -o %s -osf %s -gsf 1 -rconf CFG/Config.xml -se OTR" % (xmlPath, outputPath, outputSourcePath)
-
-    if "overlays" in xmlPath:
-        execStr += " --static"
-
-    print(execStr)
-    exitValue = os.system(execStr)
-    #exitValue = 0
-    if exitValue != 0:
-        print("\n")
-        print("Error when extracting from file " + xmlPath, file=os.sys.stderr)
-        print("Aborting...", file=os.sys.stderr)
-        print("\n")
-
-def ExtractFunc(fullPath):
-    *pathList, xmlName = fullPath.split(os.sep)
-    objectName = os.path.splitext(xmlName)[0]
-
-    outPath = os.path.join("..\\soh\\assets\\", *pathList[4:], objectName)
-    os.makedirs(outPath, exist_ok=True)
-    outSourcePath = outPath
-
-    ExtractFile(fullPath, outPath, outSourcePath)
-
-def initializeWorker(abort, test):
-    global globalAbort
-    globalAbort = abort
-
-
 def main():
-    parser = argparse.ArgumentParser(description="baserom asset extractor")
-    parser.add_argument("-s", "--single", help="asset path relative to assets/, e.g. objects/gameplay_keep")
-    parser.add_argument("-f", "--force", help="Force the extraction of every xml instead of checking the touched ones.", action="store_true")
-    parser.add_argument("-u", "--unaccounted", help="Enables ZAPD unaccounted detector warning system.", action="store_true")
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-z", "--zapd", help="Path to ZAPD executable", dest="zapd_exe", type=str)
+    parser.add_argument("rom", help="Path to the rom", type=str, nargs="?")
+    parser.add_argument("--non-interactive", help="Runs the script non-interactively for use in build scripts.", dest="non_interactive", action="store_true")
+    parser.add_argument("-v", "--verbose", help="Display rom's header checksums and their corresponding xml folder", dest="verbose", action="store_true")
+
     args = parser.parse_args()
 
-    global mainAbort
-    mainAbort = Event()
-    manager = Manager()
-    signal.signal(signal.SIGINT, SignalHandler)
+    roms = [ Z64Rom(args.rom) ] if args.rom else rom_chooser.chooseROM(args.verbose, args.non_interactive)
+    for rom in roms:
+        if (os.path.exists("Extract")):
+            shutil.rmtree("Extract")
 
-    extractedAssetsTracker = manager.dict()
-
-    asset_path = args.single
-    if asset_path is not None:
-        fullPath = os.path.join("..\\soh\\assets", "xml", asset_path + ".xml")
-        if not os.path.exists(fullPath):
-            print(f"Error. File {fullPath} doesn't exists.", file=os.sys.stderr)
-            exit(1)
-
-        ExtractFunc(fullPath)
-    else:
-        extract_text_path = "assets/text/message_data.h"
-        if os.path.isfile(extract_text_path):
-            extract_text_path = None
-        extract_staff_text_path = "assets/text/message_data_staff.h"
-        if os.path.isfile(extract_staff_text_path):
-            extract_staff_text_path = None
-
-        xmlFiles = []
-        for currentPath, _, files in os.walk(os.path.join("..\\soh\\assets", "xml")):
-            for file in files:
-                fullPath = os.path.join(currentPath, file)
-                if file.endswith(".xml"):
-                    xmlFiles.append(fullPath)
-
-        try:
-            numCores = 2
-            print("Extracting assets with " + str(numCores) + " CPU cores.")
-            with Pool(numCores, initializer=initializeWorker, initargs=(mainAbort, 0)) as p:
-                p.map(ExtractFunc, xmlFiles)
-        except Exception as e:
-            print("Warning: Multiprocessing exception ocurred.", file=os.sys.stderr)
-            print("Disabling mutliprocessing.", file=os.sys.stderr)
-
-            initializeWorker(mainAbort, 0)
-            for singlePath in xmlFiles:
-                ExtractFunc(singlePath)
-
-
-        BuildOTR()
-        shutil.rmtree("Extract")
+        BuildOTR("../soh/assets/xml/" + rom.version.xml_ver + "/", rom.file_path, zapd_exe=args.zapd_exe)
 
 if __name__ == "__main__":
-    main()
+    main()

OTRExporter/extract_baserom.py

@@ -0,0 +1,53 @@
+#!/usr/bin/python3
+
+import os
+import sys
+import struct
+from multiprocessing import Pool, cpu_count
+from rom_info import Z64Rom
+import rom_chooser
+
+
+rom = None
+
+def initialize_worker(input_rom):
+    global rom
+    rom = input_rom
+
+def ExtractFunc(i):
+
+    dma_file = rom.getDmaEntryByIndex(i)
+    dma_data = rom.readDmaEntry(dma_file)
+
+    filename = '../soh/baserom/' + rom.version.file_table[i]
+    print('extracting ' + filename + " (0x%08X, 0x%08X)" % (dma_file.virtStart, dma_file.virtEnd))
+
+    try:
+        with open(filename, 'wb') as f:
+            f.write(dma_data)
+    except IOError:
+        print('failed to write file ' + filename)
+
+    # TODO: handle this better
+    if dma_file.compressed:
+        os.system('tools/yaz0 -d ' + filename + ' ' + filename)
+
+#####################################################################
+
+def main():
+    try:
+        os.mkdir('../soh/baserom')
+    except:
+        pass
+
+    rom_path = rom_chooser.chooseROM()
+    input_rom = Z64Rom(rom_path)
+
+    # extract files
+    num_cores = cpu_count()
+    print("Extracting baserom with " + str(num_cores) + " CPU cores.")
+    with Pool(num_cores, initialize_worker, (input_rom,)) as p:
+        p.map(ExtractFunc, range(len(input_rom.version.file_table)))
+
+if __name__ == "__main__":
+    main()

OTRExporter/rom_chooser.py

@@ -0,0 +1,57 @@
+import os, sys, glob
+
+from rom_info import Z64Rom
+
+def chooseROM(verbose=False, non_interactive=False):
+    roms = []
+
+    for file in glob.glob("*.z64"):
+        rom = Z64Rom(file)
+        if rom.is_valid:
+            roms.append(rom)
+
+    if not (roms):
+        print("Error: No roms located, place one in the OTRExporter directory", file=os.sys.stderr)
+        sys.exit(1)
+
+    if (len(roms) == 1):
+        return roms
+
+    if non_interactive:
+        romsToExtract = []
+        foundMq = False
+        foundOot = False
+        for rom in roms:
+            if rom.isMq and not foundMq:
+                romsToExtract.append(rom)
+                foundMq = True
+            elif not rom.isMq and not foundOot:
+                romsToExtract.append(rom)
+                foundOot = True
+        return romsToExtract
+
+    print(f"{len(roms)} roms found, please select one by pressing 1-{len(roms)}")
+    print()
+
+    for i in range(len(roms)):
+        print(f"[{i+1:>2d}] {roms[i].file_path}")
+        if verbose:
+            print(f"     Checksum: {roms[i].checksum.value}, Version XML: {roms[i].version.xml_ver}")
+            print()
+
+    while(1):
+        try:
+            selection = int(input())
+        except KeyboardInterrupt:
+            sys.exit(1)
+        except:
+            print("Bad input. Try again with the number keys.")
+            continue
+
+        if (selection < 1 or selection > len(roms)):
+            print("Bad input. Try again.")
+            continue
+
+        else: break
+
+    return [ roms[selection - 1] ]

OTRExporter/rom_info.py

@@ -0,0 +1,97 @@
+from enum import Enum
+from tabnanny import check
+import struct
+
+class Checksums(Enum):
+    OOT_NTSC_10 = "EC7011B7"
+    OOT_NTSC_11 = "D43DA81F"
+    OOT_NTSC_12 = "693BA2AE"
+    OOT_PAL_10 = "B044B569"
+    OOT_PAL_11 = "B2055FBD"
+    OOT_NTSC_JP_GC_CE = "F7F52DB8"
+    OOT_NTSC_JP_GC = "F611F4BA"
+    OOT_NTSC_US_GC = "F3DD35BA"
+    OOT_PAL_GC = "09465AC3"
+    OOT_NTSC_JP_MQ = "F43B45BA"
+    OOT_NTSC_US_MQ = "F034001A"
+    OOT_PAL_MQ = "1D4136F3"
+    OOT_PAL_GC_DBG1 = "871E1C92"
+    OOT_PAL_GC_DBG2 = "87121EFE"
+    OOT_PAL_GC_MQ_DBG = "917D18F6"
+    OOT_IQUE_TW = "3D81FB3E"
+    OOT_IQUE_CN = "B1E1E07B"
+    OOT_UNKNOWN = "FFFFFFFF"
+
+    @classmethod
+    def has_value(self, value):
+        return value in self._value2member_map_
+
+class RomVersion:
+    def __init__(self, file_table_path, file_table_off, xml_ver):
+        self.file_table_off = file_table_off
+        self.xml_ver = xml_ver
+        with open(file_table_path, 'r') as f:
+            self.file_table = [line.strip('\n') for line in f]
+
+ROM_INFO_TABLE = dict()
+ROM_INFO_TABLE[Checksums.OOT_PAL_GC] = RomVersion("CFG/filelists/gamecube_pal.txt", 0x7170, "GC_NMQ_PAL_F")
+ROM_INFO_TABLE[Checksums.OOT_PAL_GC_DBG1] = RomVersion("CFG/filelists/dbg.txt", 0x12F70, "GC_NMQ_D")
+ROM_INFO_TABLE[Checksums.OOT_PAL_GC_MQ_DBG] = RomVersion("CFG/filelists/dbg.txt", 0x12F70, "GC_MQ_D")
+
+class RomDmaEntry:
+    def __init__(self, rom, i):
+
+        off = rom.version.file_table_off + 16 * i
+
+        (self.virtStart, \
+        self.virtEnd, \
+        self.physStart, \
+        self.physEnd) = struct.unpack('>IIII', rom.rom_data[off:off+4*4])
+
+        self.compressed = self.physEnd != 0
+        self.size = self.physEnd - self.physStart \
+                if self.compressed \
+                else self.virtEnd - self.virtStart
+        self.name = rom.version.file_table[i]
+
+
+class Z64Rom:
+    def __init__(self, file_path):
+        self.file_path = file_path
+        with open(file_path, 'rb') as f:
+            self.rom_data = f.read()
+
+        self.is_valid = len(self.rom_data) > 20 * 1024 * 1024
+
+        if not self.is_valid:
+            return
+
+        # get checkum
+        checksum_str = self.rom_data[16:16+4].hex().upper()
+        self.checksum = Checksums(checksum_str) if Checksums.has_value(checksum_str) else Checksums.OOT_UNKNOWN
+
+        if self.checksum == Checksums.OOT_UNKNOWN:
+            self.is_valid = False
+            return
+        
+        if self.checksum in [Checksums.OOT_NTSC_JP_MQ, Checksums.OOT_NTSC_US_MQ, Checksums.OOT_PAL_GC_MQ_DBG, Checksums.OOT_PAL_MQ]:
+            self.isMq = True
+        else:
+            self.isMq = False
+
+        # get rom version
+        self.version = ROM_INFO_TABLE[self.checksum]
+
+    def getDmaEntryByIndex(self, i):
+        return RomDmaEntry(self, i)
+
+    def readDmaEntry(self, entry):
+        return self.rom_data[entry.physStart:entry.physStart + entry.size]
+
+    @staticmethod
+    def isValidRom(rom_path):
+        return Z64Rom(rom_path).is_valid
+    
+    @staticmethod
+    def isMqRom(rom_path):
+        return Z64Rom(rom_path).isMq

OTRGui/CMake/Default.cmake

@@ -0,0 +1,65 @@
+################################################################################
+# Command for variable_watch. This command issues error message, if a variable
+# is changed. If variable PROPERTY_READER_GUARD_DISABLED is TRUE nothing happens
+#     variable_watch(<variable> property_reader_guard)
+################################################################################
+function(property_reader_guard VARIABLE ACCESS VALUE CURRENT_LIST_FILE STACK)
+    if("${PROPERTY_READER_GUARD_DISABLED}")
+        return()
+    endif()
+
+    if("${ACCESS}" STREQUAL "MODIFIED_ACCESS")
+        message(FATAL_ERROR
+            " Variable ${VARIABLE} is not supposed to be changed.\n"
+            " It is used only for reading target property ${VARIABLE}.\n"
+            " Use\n"
+            "     set_target_properties(\"<target>\" PROPERTIES \"${VARIABLE}\" \"<value>\")\n"
+            " or\n"
+            "     set_target_properties(\"<target>\" PROPERTIES \"${VARIABLE}_<CONFIG>\" \"<value>\")\n"
+            " instead.\n")
+    endif()
+endfunction()
+
+################################################################################
+# Create variable <name> with generator expression that expands to value of
+# target property <name>_<CONFIG>. If property is empty or not set then property
+# <name> is used instead. Variable <name> has watcher property_reader_guard that
+# doesn't allow to edit it.
+#     create_property_reader(<name>)
+# Input:
+#     name - Name of watched property and output variable
+################################################################################
+function(create_property_reader NAME)
+    set(PROPERTY_READER_GUARD_DISABLED TRUE)
+    set(CONFIG_VALUE "$<TARGET_GENEX_EVAL:${PROPS_TARGET},$<TARGET_PROPERTY:${PROPS_TARGET},${NAME}_$<UPPER_CASE:$<CONFIG>>>>")
+    set(IS_CONFIG_VALUE_EMPTY "$<STREQUAL:${CONFIG_VALUE},>")
+    set(GENERAL_VALUE "$<TARGET_GENEX_EVAL:${PROPS_TARGET},$<TARGET_PROPERTY:${PROPS_TARGET},${NAME}>>")
+    set("${NAME}" "$<IF:${IS_CONFIG_VALUE_EMPTY},${GENERAL_VALUE},${CONFIG_VALUE}>" PARENT_SCOPE)
+    variable_watch("${NAME}" property_reader_guard)
+endfunction()
+
+################################################################################
+# Set property $<name>_${PROPS_CONFIG_U} of ${PROPS_TARGET} to <value>
+#     set_config_specific_property(<name> <value>)
+# Input:
+#     name  - Prefix of property name
+#     value - New value
+################################################################################
+function(set_config_specific_property NAME VALUE)
+    set_target_properties("${PROPS_TARGET}" PROPERTIES "${NAME}_${PROPS_CONFIG_U}" "${VALUE}")
+endfunction()
+
+################################################################################
+
+create_property_reader("TARGET_NAME")
+create_property_reader("OUTPUT_DIRECTORY")
+
+set_config_specific_property("TARGET_NAME" "${PROPS_TARGET}")
+set_config_specific_property("OUTPUT_NAME" "${TARGET_NAME}")
+set_config_specific_property("ARCHIVE_OUTPUT_NAME" "${TARGET_NAME}")
+set_config_specific_property("LIBRARY_OUTPUT_NAME" "${TARGET_NAME}")
+set_config_specific_property("RUNTIME_OUTPUT_NAME" "${TARGET_NAME}")
+
+set_config_specific_property("ARCHIVE_OUTPUT_DIRECTORY" "${OUTPUT_DIRECTORY}")
+set_config_specific_property("LIBRARY_OUTPUT_DIRECTORY" "${OUTPUT_DIRECTORY}")
+set_config_specific_property("RUNTIME_OUTPUT_DIRECTORY" "${OUTPUT_DIRECTORY}")

OTRGui/CMake/DefaultCXX.cmake

@@ -0,0 +1,12 @@
+include("${CMAKE_CURRENT_LIST_DIR}/Default.cmake")
+
+set_config_specific_property("OUTPUT_DIRECTORY" "${CMAKE_SOURCE_DIR}$<$<NOT:$<STREQUAL:${CMAKE_VS_PLATFORM_NAME},Win32>>:/${CMAKE_VS_PLATFORM_NAME}>/${PROPS_CONFIG}")
+
+if(MSVC)
+    create_property_reader("DEFAULT_CXX_EXCEPTION_HANDLING")
+    create_property_reader("DEFAULT_CXX_DEBUG_INFORMATION_FORMAT")
+
+    set_target_properties("${PROPS_TARGET}" PROPERTIES MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>DLL")
+    set_config_specific_property("DEFAULT_CXX_EXCEPTION_HANDLING" "/EHsc")
+    set_config_specific_property("DEFAULT_CXX_DEBUG_INFORMATION_FORMAT" "/Zi")
+endif()

OTRGui/CMake/Utils.cmake

@@ -0,0 +1,234 @@
+# utils file for projects came from visual studio solution with cmake-converter.
+
+################################################################################
+# Wrap each token of the command with condition
+################################################################################
+cmake_policy(PUSH)
+cmake_policy(SET CMP0054 NEW)
+macro(prepare_commands)
+    unset(TOKEN_ROLE)
+    unset(COMMANDS)
+    foreach(TOKEN ${ARG_COMMANDS})
+        if("${TOKEN}" STREQUAL "COMMAND")
+            set(TOKEN_ROLE "KEYWORD")
+        elseif("${TOKEN_ROLE}" STREQUAL "KEYWORD")
+            set(TOKEN_ROLE "CONDITION")
+        elseif("${TOKEN_ROLE}" STREQUAL "CONDITION")
+            set(TOKEN_ROLE "COMMAND")
+        elseif("${TOKEN_ROLE}" STREQUAL "COMMAND")
+            set(TOKEN_ROLE "ARG")
+        endif()
+
+        if("${TOKEN_ROLE}" STREQUAL "KEYWORD")
+            list(APPEND COMMANDS "${TOKEN}")
+        elseif("${TOKEN_ROLE}" STREQUAL "CONDITION")
+            set(CONDITION ${TOKEN})
+        elseif("${TOKEN_ROLE}" STREQUAL "COMMAND")
+            list(APPEND COMMANDS "$<$<NOT:${CONDITION}>:${DUMMY}>$<${CONDITION}:${TOKEN}>")
+        elseif("${TOKEN_ROLE}" STREQUAL "ARG")
+            list(APPEND COMMANDS "$<${CONDITION}:${TOKEN}>")
+        endif()
+    endforeach()
+endmacro()
+cmake_policy(POP)
+
+################################################################################
+# Transform all the tokens to absolute paths
+################################################################################
+macro(prepare_output)
+    unset(OUTPUT)
+    foreach(TOKEN ${ARG_OUTPUT})
+        if(IS_ABSOLUTE ${TOKEN})
+            list(APPEND OUTPUT "${TOKEN}")
+        else()
+            list(APPEND OUTPUT "${CMAKE_CURRENT_SOURCE_DIR}/${TOKEN}")
+        endif()
+    endforeach()
+endmacro()
+
+################################################################################
+# Parse add_custom_command_if args.
+#
+# Input:
+#     PRE_BUILD  - Pre build event option
+#     PRE_LINK   - Pre link event option
+#     POST_BUILD - Post build event option
+#     TARGET     - Target
+#     OUTPUT     - List of output files
+#     DEPENDS    - List of files on which the command depends
+#     COMMANDS   - List of commands(COMMAND condition1 commannd1 args1 COMMAND
+#                  condition2 commannd2 args2 ...)
+# Output:
+#     OUTPUT     - Output files
+#     DEPENDS    - Files on which the command depends
+#     COMMENT    - Comment
+#     PRE_BUILD  - TRUE/FALSE
+#     PRE_LINK   - TRUE/FALSE
+#     POST_BUILD - TRUE/FALSE
+#     TARGET     - Target name
+#     COMMANDS   - Prepared commands(every token is wrapped in CONDITION)
+#     NAME       - Unique name for custom target
+#     STEP       - PRE_BUILD/PRE_LINK/POST_BUILD
+################################################################################
+function(add_custom_command_if_parse_arguments)
+    cmake_parse_arguments("ARG" "PRE_BUILD;PRE_LINK;POST_BUILD" "TARGET;COMMENT" "DEPENDS;OUTPUT;COMMANDS" ${ARGN})
+
+    if(WIN32)
+        set(DUMMY "cd.")
+    elseif(UNIX)
+        set(DUMMY "true")
+    endif()
+
+    prepare_commands()
+    prepare_output()
+
+    set(DEPENDS "${ARG_DEPENDS}")
+    set(COMMENT "${ARG_COMMENT}")
+    set(PRE_BUILD "${ARG_PRE_BUILD}")
+    set(PRE_LINK "${ARG_PRE_LINK}")
+    set(POST_BUILD "${ARG_POST_BUILD}")
+    set(TARGET "${ARG_TARGET}")
+    if(PRE_BUILD)
+        set(STEP "PRE_BUILD")
+    elseif(PRE_LINK)
+        set(STEP "PRE_LINK")
+    elseif(POST_BUILD)
+        set(STEP "POST_BUILD")
+    endif()
+    set(NAME "${TARGET}_${STEP}")
+
+    set(OUTPUT "${OUTPUT}" PARENT_SCOPE)
+    set(DEPENDS "${DEPENDS}" PARENT_SCOPE)
+    set(COMMENT "${COMMENT}" PARENT_SCOPE)
+    set(PRE_BUILD "${PRE_BUILD}" PARENT_SCOPE)
+    set(PRE_LINK "${PRE_LINK}" PARENT_SCOPE)
+    set(POST_BUILD "${POST_BUILD}" PARENT_SCOPE)
+    set(TARGET "${TARGET}" PARENT_SCOPE)
+    set(COMMANDS "${COMMANDS}" PARENT_SCOPE)
+    set(STEP "${STEP}" PARENT_SCOPE)
+    set(NAME "${NAME}" PARENT_SCOPE)
+endfunction()
+
+################################################################################
+# Add conditional custom command
+#
+# Generating Files
+# The first signature is for adding a custom command to produce an output:
+#     add_custom_command_if(
+#         <OUTPUT output1 [output2 ...]>
+#         <COMMANDS>
+#         <COMMAND condition command1 [args1...]>
+#         [COMMAND condition command2 [args2...]]
+#         [DEPENDS [depends...]]
+#         [COMMENT comment]
+#
+# Build Events
+#     add_custom_command_if(
+#         <TARGET target>
+#         <PRE_BUILD | PRE_LINK | POST_BUILD>
+#         <COMMAND condition command1 [args1...]>
+#         [COMMAND condition command2 [args2...]]
+#         [COMMENT comment]
+#
+# Input:
+#     output     - Output files the command is expected to produce
+#     condition  - Generator expression for wrapping the command
+#     command    - Command-line(s) to execute at build time.
+#     args       - Command`s args
+#     depends    - Files on which the command depends
+#     comment    - Display the given message before the commands are executed at
+#                  build time.
+#     PRE_BUILD  - Run before any other rules are executed within the target
+#     PRE_LINK   - Run after sources have been compiled but before linking the
+#                  binary
+#     POST_BUILD - Run after all other rules within the target have been
+#                  executed
+################################################################################
+function(add_custom_command_if)
+    add_custom_command_if_parse_arguments(${ARGN})
+
+    if(OUTPUT AND TARGET)
+        message(FATAL_ERROR  "Wrong syntax. A TARGET and OUTPUT can not both be specified.")
+    endif()
+
+    if(OUTPUT)
+        add_custom_command(OUTPUT ${OUTPUT}
+                           ${COMMANDS}
+                           DEPENDS ${DEPENDS}
+                           WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+                           COMMENT ${COMMENT})
+    elseif(TARGET)
+        if(PRE_BUILD AND NOT ${CMAKE_GENERATOR} MATCHES "Visual Studio")
+            add_custom_target(
+                ${NAME}
+                ${COMMANDS}
+                WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+                COMMENT ${COMMENT})
+            add_dependencies(${TARGET} ${NAME})
+        else()
+            add_custom_command(
+                TARGET ${TARGET}
+                ${STEP}
+                ${COMMANDS}
+                WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+                COMMENT ${COMMENT})
+        endif()
+    else()
+        message(FATAL_ERROR "Wrong syntax. A TARGET or OUTPUT must be specified.")
+    endif()
+endfunction()
+
+################################################################################
+# Use props file for a target and configs
+#     use_props(<target> <configs...> <props_file>)
+# Inside <props_file> there are following variables:
+#     PROPS_TARGET   - <target>
+#     PROPS_CONFIG   - One of <configs...>
+#     PROPS_CONFIG_U - Uppercase PROPS_CONFIG
+# Input:
+#     target      - Target to apply props file
+#     configs     - Build configurations to apply props file
+#     props_file  - CMake script
+################################################################################
+macro(use_props TARGET CONFIGS PROPS_FILE)
+    set(PROPS_TARGET "${TARGET}")
+    foreach(PROPS_CONFIG ${CONFIGS})
+        string(TOUPPER "${PROPS_CONFIG}" PROPS_CONFIG_U)
+
+        get_filename_component(ABSOLUTE_PROPS_FILE "${PROPS_FILE}" ABSOLUTE BASE_DIR "${CMAKE_CURRENT_LIST_DIR}")
+        if(EXISTS "${ABSOLUTE_PROPS_FILE}")
+            include("${ABSOLUTE_PROPS_FILE}")
+        else()
+            message(WARNING "Corresponding cmake file from props \"${ABSOLUTE_PROPS_FILE}\" doesn't exist")
+        endif()
+    endforeach()
+endmacro()
+
+################################################################################
+# Add compile options to source file
+#     source_file_compile_options(<source_file> [compile_options...])
+# Input:
+#     source_file     - Source file
+#     compile_options - Options to add to COMPILE_FLAGS property
+################################################################################
+function(source_file_compile_options SOURCE_FILE)
+    if("${ARGC}" LESS_EQUAL "1")
+        return()
+    endif()
+
+    get_source_file_property(COMPILE_OPTIONS "${SOURCE_FILE}" COMPILE_OPTIONS)
+
+    if(COMPILE_OPTIONS)
+        list(APPEND COMPILE_OPTIONS ${ARGN})
+    else()
+        set(COMPILE_OPTIONS "${ARGN}")
+    endif()
+
+    set_source_files_properties("${SOURCE_FILE}" PROPERTIES COMPILE_OPTIONS "${COMPILE_OPTIONS}")
+endfunction()
+
+################################################################################
+# Default properties of visual studio projects
+################################################################################
+set(DEFAULT_CXX_PROPS "${CMAKE_CURRENT_LIST_DIR}/DefaultCXX.cmake")
+set(DEFAULT_Fortran_PROPS "${CMAKE_CURRENT_LIST_DIR}/DefaultFortran.cmake")

OTRGui/CMakeLists.txt

@@ -3,27 +3,66 @@ project(OTRGui)
 
 set(PLATFORM "Desktop")
 set(CMAKE_CXX_STANDARD 20)
-set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/build)
+#set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/build)
 set(APP_ICON_RESOURCE_WINDOWS ${CMAKE_CURRENT_SOURCE_DIR}/appicon.rc)
 
-add_subdirectory(libs/raylib)
+if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
+    set(OpenGL_GL_PREFERENCE "GLVND")
+endif()
+
+include(CMake/Utils.cmake)
+
+add_subdirectory(libs/raylib EXCLUDE_FROM_ALL)
 
 include_directories(src)
 include_directories(src/game)
 include_directories(include)
 
-include_external_msproject(ZAPD ../../ZAPDTR/ZAPD/ZAPD.vcproj)
-include_external_msproject(ZAPDUtils ../../ZAPDTR/ZAPDUtils/ZAPDUtils.vcproj)
-include_external_msproject(libultraship ../../libultraship/libultraship/libultraship.vcproj)
-include_external_msproject(OTRExporter ../../OTRExporter/OTRExporter/OTRExporter.vcproj)
+if (NOT TARGET libultraship)
+    add_subdirectory(../libultraship ${CMAKE_BINARY_DIR}/libultraship)
+endif()
+if (NOT TARGET ZAPD)
+    add_subdirectory(../ZAPDTR/ZAPD ${CMAKE_BINARY_DIR}/ZAPD)
+endif()
+if (NOT TARGET ZAPDUtils)
+    add_subdirectory(../libultraship/extern/ZAPDUtils ${CMAKE_BINARY_DIR}/ZAPDUtils)
+endif()
+if (NOT TARGET OTRExporter)
+    add_subdirectory(../OTRExporter/OTRExporter ${CMAKE_BINARY_DIR}/OTRExporter)
+endif()
+if (NOT TARGET storm)
+    add_subdirectory(../libultraship/extern/StormLib ${CMAKE_BINARY_DIR}/StormLib)
+endif()
 
 file(GLOB_RECURSE HEADERS src/*.h)
 file(GLOB_RECURSE SOURCES src/*.cpp)
 file(GLOB_RECURSE C_SOURCES src/*.c)
 
-add_executable(${PROJECT_NAME} ${SOURCES} ${C_SOURCES} ${HEADERS} ${APP_ICON_RESOURCE_WINDOWS})
-add_custom_command(TARGET ${PROJECT_NAME} PRE_BUILD COMMAND ${CMAKE_COMMAND} -Dsrc_dir="${CMAKE_SOURCE_DIR}/assets" -Ddst_dir="${CMAKE_CURRENT_BINARY_DIR}/assets" -P "${CMAKE_CURRENT_SOURCE_DIR}/Overwrite.cmake")
-add_custom_command(TARGET ${PROJECT_NAME} PRE_BUILD COMMAND ${CMAKE_COMMAND} -Dsrc_dir="${CMAKE_SOURCE_DIR}/../OTRExporter/assets" -Ddst_dir="${CMAKE_CURRENT_BINARY_DIR}/assets/game" -P "${CMAKE_CURRENT_SOURCE_DIR}/Overwrite.cmake")
-add_custom_command(TARGET ${PROJECT_NAME} PRE_BUILD COMMAND ${CMAKE_COMMAND} -Dsrc_dir="${CMAKE_SOURCE_DIR}/../soh/assets/xml" -Ddst_dir="${CMAKE_CURRENT_BINARY_DIR}/assets/extractor/xmls" -P "${CMAKE_CURRENT_SOURCE_DIR}/Overwrite.cmake")
+add_executable(${PROJECT_NAME} EXCLUDE_FROM_ALL ${SOURCES} ${C_SOURCES} ${HEADERS} ${APP_ICON_RESOURCE_WINDOWS})
+
+if (CMAKE_SYSTEM_NAME STREQUAL "Windows")
+use_props(${PROJECT_NAME} "${CMAKE_CONFIGURATION_TYPES}" "${DEFAULT_CXX_PROPS}")
+endif()
+
+add_custom_target(Assets ALL
+    COMMAND ${CMAKE_COMMAND} -Dsrc_dir="${CMAKE_CURRENT_SOURCE_DIR}/assets" -Ddst_dir="${CMAKE_CURRENT_BINARY_DIR}/assets" -P "${CMAKE_CURRENT_SOURCE_DIR}/Overwrite.cmake"
+    COMMAND ${CMAKE_COMMAND} -Dsrc_dir="${CMAKE_CURRENT_SOURCE_DIR}/../OTRExporter/assets" -Ddst_dir="${CMAKE_CURRENT_BINARY_DIR}/assets/game" -P "${CMAKE_CURRENT_SOURCE_DIR}/Overwrite.cmake"
+    COMMAND ${CMAKE_COMMAND} -Dsrc_dir="${CMAKE_CURRENT_SOURCE_DIR}/../soh/assets/xml" -Ddst_dir="${CMAKE_CURRENT_BINARY_DIR}/assets/extractor/xmls" -P "${CMAKE_CURRENT_SOURCE_DIR}/Overwrite.cmake"
+    )
+ 
+add_dependencies(OTRGui Assets)
 
 target_link_libraries(${PROJECT_NAME} PUBLIC raylib)
+
+target_include_directories(${PROJECT_NAME} PRIVATE
+	${CMAKE_CURRENT_SOURCE_DIR}/../libultraship
+	.
+)
+
+INSTALL(TARGETS OTRGui DESTINATION . COMPONENT ship OPTIONAL)
+install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/assets
+        DESTINATION .
+	COMPONENT ship
+)
+INSTALL(TARGETS ZAPD DESTINATION assets/extractor COMPONENT ship)
+

OTRGui/Overwrite.cmake

@@ -1,10 +1,15 @@
-file(GLOB_RECURSE _file_list RELATIVE "${src_dir}" "${src_dir}/*")
+include(CMakePrintHelpers)
+
+string(REPLACE "\\ " " " sources_dir "${src_dir}")
+string(REPLACE "\\ " " " destination_dir "${dst_dir}")
+
+file(GLOB_RECURSE _file_list RELATIVE "${sources_dir}" "${sources_dir}/*")
 
 foreach( each_file ${_file_list} )
-  set(destinationfile "${dst_dir}/${each_file}")
-  set(sourcefile "${src_dir}/${each_file}")
+  set(destinationfile "${destination_dir}/${each_file}")
+  set(sourcefile "${sources_dir}/${each_file}")
   if(NOT EXISTS ${destinationfile} OR ${sourcefile} IS_NEWER_THAN ${destinationfile})
     get_filename_component(destinationdir ${destinationfile} DIRECTORY)
     file(COPY ${sourcefile} DESTINATION ${destinationdir})
   endif()
-endforeach(each_file)
+endforeach(each_file)

OTRGui/assets/extractor/Config.xml

@@ -1,8 +0,0 @@
-<Root>
-    <SymbolMap File="symbols/SymbolMap_OoTMqDbg.txt"/>
-    <ActorList File="symbols/ActorList_OoTMqDbg.txt"/>
-    <ObjectList File="symbols/ObjectList_OoTMqDbg.txt"/>
-    <ExternalXMLFolder Path="assets/extractor/xmls/"/>
-	<TexturePool File="TexturePool.xml"/>
-    <ExternalFile XmlPath="objects/gameplay_keep.xml" OutPath="objects/gameplay_keep/"/>
-</Root>

OTRGui/assets/extractor/Config_GC_MQ_D.xml

@@ -0,0 +1,8 @@
+<Root>
+    <SymbolMap File="symbols/SymbolMap_OoTMqDbg.txt"/>
+    <ActorList File="symbols/ActorList_OoTMqDbg.txt"/>
+    <ObjectList File="symbols/ObjectList_OoTMqDbg.txt"/>
+    <ExternalXMLFolder Path="assets/extractor/xmls/GC_MQ_D/"/>
+	<TexturePool File="TexturePool.xml"/>
+    <ExternalFile XmlPath="objects/gameplay_keep.xml" OutPath="objects/gameplay_keep/"/>
+</Root>

OTRGui/assets/extractor/Config_GC_NMQ_D.xml

@@ -0,0 +1,8 @@
+<Root>
+    <SymbolMap File="symbols/SymbolMap_OoTMqDbg.txt"/>
+    <ActorList File="symbols/ActorList_OoTMqDbg.txt"/>
+    <ObjectList File="symbols/ObjectList_OoTMqDbg.txt"/>
+    <ExternalXMLFolder Path="assets/extractor/xmls/GC_NMQ_D/"/>
+	<TexturePool File="TexturePool.xml"/>
+    <ExternalFile XmlPath="objects/gameplay_keep.xml" OutPath="objects/gameplay_keep/"/>
+</Root>

OTRGui/assets/extractor/Config_GC_NMQ_PAL_F.xml

@@ -0,0 +1,8 @@
+<Root>
+    <SymbolMap File="symbols/SymbolMap_OoTMqDbg.txt"/>
+    <ActorList File="symbols/ActorList_OoTMqDbg.txt"/>
+    <ObjectList File="symbols/ObjectList_OoTMqDbg.txt"/>
+    <ExternalXMLFolder Path="assets/extractor/xmls/GC_NMQ_PAL_F/"/>
+	<TexturePool File="TexturePool.xml"/>
+    <ExternalFile XmlPath="objects/gameplay_keep.xml" OutPath="objects/gameplay_keep/"/>
+</Root>

OTRGui/src/game/game.cpp

@@ -18,6 +18,7 @@ Shader shader = { 0 };
 Light light = { 0 };
 Vector3 lightPos = { -5.0f, 10.0f, 10.0f };
 Vector2 dragOffset;
+bool isDragging = false;
 std::string sohFolder = NULLSTR;
 bool extracting = false;
 bool rom_ready = false;
@@ -25,6 +26,7 @@ bool single_thread = false;
 bool hide_second_btn = false;
 RomVersion version;
 const char* patched_rom = "tmp/rom.z64";
+extern bool oldExtractMode;
 
 static std::string currentStep = "None";
 
@@ -65,23 +67,41 @@ void OTRGame::init(){
 		mat.shader = shader;
 	}
 
-	if(fs::exists("soh.exe") && !fs::exists("oot.otr")) {
+	if (fs::exists("soh.exe") || fs::exists("soh.elf")) {
 		hide_second_btn = true;
 		sohFolder = ".";
 	}
 }
 
-void ExtractRom() {
-	const WriteResult result = ExtractBaserom(patched_rom);
+void ExtractRom()
+{
+	WriteResult result;
+
+	if (oldExtractMode)
+		ExtractBaserom(patched_rom);
+	else
+		result.error = NULLSTR;
+
 	if (result.error == NULLSTR) {
-		if (MoonUtils::exists("oot.otr")) MoonUtils::rm("oot.otr");
-		startWorker();
+		if (MoonUtils::exists("oot.otr") && !version.isMQ) MoonUtils::rm("oot.otr");
+		if (MoonUtils::exists("oot-mq.otr") && version.isMQ) MoonUtils::rm("oot-mq.otr");
+		if (MoonUtils::exists("Extract")) MoonUtils::rm("Extract");
+
+		MoonUtils::mkdir("Extract");
+		//MoonUtils::copy("tmp/baserom/Audiobank", "Extract/Audiobank");
+		//MoonUtils::copy("tmp/baserom/Audioseq", "Extract/Audioseq");
+		//MoonUtils::copy("tmp/baserom/Audiotable", "Extract/Audiotable");
+		//MoonUtils::copy("tmp/baserom/version", "Extract/version");
+
+		MoonUtils::copy("assets/game/", "Extract/assets/");
+
+		startWorker(version);
 		extracting = true;
 	}
 }
 
 void OTRGame::update(){
-	updateWorker(sohFolder);
+	updateWorker(sohFolder, version);
 	this->ModelRotation += 50 * GetFrameTime();
 	UpdateLightValues(shader, light);
 
@@ -95,69 +115,103 @@ void OTRGame::update(){
 }
 
 void OTRGame::draw() {
+	Vector2 windowSize(GetScreenWidth(), GetScreenHeight());
+	Rectangle titlebar = Rectangle(0, 0, windowSize.x - 50, 35);
+	Vector2 mousePos = GetMousePosition();
+	Vector2 mouseDelta = GetMouseDelta();
+
+	if (IsMouseButtonPressed(MOUSE_BUTTON_LEFT) && !isDragging &&
+		mousePos.x >= titlebar.x && mousePos.y >= titlebar.y && mousePos.x <= titlebar.x + titlebar.width && mousePos.y <= titlebar.y + titlebar.height) {
+		isDragging = true;
+		dragOffset = mousePos;
+	}
+	else if (IsMouseButtonReleased(MOUSE_BUTTON_LEFT) && isDragging) {
+		isDragging = false;
+		dragOffset = Vector2(0, 0);
+	}
+
+	if (isDragging && (mouseDelta.x != 0.0f || mouseDelta.y != 0.0f)) {
+		Vector2 wndPos = GetWindowPosition();
+		wndPos = Vector2(wndPos.x + (mousePos.x - dragOffset.x), wndPos.y + (mousePos.y - dragOffset.y));
+
+		// Calculate virtual screen total size in case there are multiple monitors
+
+		int vsX1 = 0, vsY1 = 0, vsX2 = 0, vsY2 = 0;
+		int monitorCount = GetMonitorCount();
+
+		for (int m = 0; m < monitorCount; m++) {
+			Vector2 monitorPos = GetMonitorPosition(m);
+			Vector2 monitorSize = Vector2(GetMonitorWidth(m), GetMonitorHeight(m));
+
+			if (monitorPos.x < vsX1) vsX1 = monitorPos.x;
+			if (monitorPos.y < vsY1) vsY1 = monitorPos.y;
+			if (monitorPos.x + monitorSize.x > vsX2) vsX2 = monitorPos.x + monitorSize.x;
+			if (monitorPos.y + monitorSize.y > vsY2) vsY2 = monitorPos.y + monitorSize.y;
+		}
+
+		// Clamp the window to the borders of the monitors
+		if (wndPos.x < vsX1) wndPos.x = vsX1;
+		if (wndPos.x < vsX1) wndPos.x = vsX1;
+		if (wndPos.y < vsY1) wndPos.y = vsY1;
+		if (wndPos.x + windowSize.x > vsX2) wndPos.x = vsX2 - windowSize.x;
+		if (wndPos.y + windowSize.y > vsY2) wndPos.y = vsY2 - windowSize.y;
+
+		SetWindowPosition(wndPos.x, wndPos.y);
+	}
+
 	BeginDrawing();
-		ClearBackground(Color(40, 40, 40, 255));
-		Vector3 windowSize(GetScreenWidth(), GetScreenHeight());
-		Rectangle titlebar = Rectangle(0, 0, windowSize.x - 50, 35);
-		Vector2 mousePos = Vector2(GetMouseX(), GetMouseY());
-		bool hoveredTitlebar = mousePos.x >= titlebar.x && mousePos.y >= titlebar.y && mousePos.x <= titlebar.x + titlebar.width && mousePos.y <= titlebar.y + titlebar.height;
+	ClearBackground(Color(40, 40, 40, 255));
 
-		if (hoveredTitlebar && IsMouseButtonDown(MOUSE_BUTTON_LEFT)) {
-			if (dragOffset.x == 0 && dragOffset.y == 0) dragOffset = mousePos;
-			Vector2 wndPos = GetWindowPosition();
+	DrawTexture(Textures["Frame"], 0, 0, WHITE);
 
-			SetWindowPosition(wndPos.x + (mousePos.x - dragOffset.x), wndPos.y + (mousePos.y - dragOffset.y));
-		}
-		else dragOffset = Vector2(0, 0);
+	Texture2D titleTex = Textures["Title"];
+	DrawTexture(titleTex, windowSize.x / 2 - titleTex.width / 2, titlebar.height / 2 - titleTex.height / 2, WHITE);
 
-		DrawTexture(Textures["Frame"], 0, 0, WHITE);
+	if (UIUtils::GuiIcon("Exit", windowSize.x - 36, titlebar.height / 2 - 10) && (extracting && currentStep.find("Done") != std::string::npos || !extracting)) {
+		closeRequested = true;
+	}
 
-		Texture2D titleTex = Textures["Title"];
-		DrawTexture(titleTex, windowSize.x / 2 - titleTex.width / 2, titlebar.height / 2 - titleTex.height / 2, WHITE);
+	BeginMode3D(camera);
+	DrawModelEx(Models["Ship"], Vector3Zero(), Vector3(.0f, 1.0f, .0f), this->ModelRotation, SCALE(1.0f), WHITE);
+	EndMode3D();
 
-		if (UIUtils::GuiIcon("Exit", windowSize.x - 36, titlebar.height / 2 - 10) && (extracting && currentStep.find("Done") != std::string::npos || !extracting)) {
-			CloseWindow();
-		}
+	constexpr float text_y = 125.f;
+	UIUtils::GuiShadowText(("Rom Type: " + version.version).c_str(), 32, text_y, 10, WHITE, BLACK);
+	UIUtils::GuiShadowText("Tool Version: 1.0", 32, text_y + 15, 10, WHITE, BLACK);
+	UIUtils::GuiShadowText("OTR Version: 1.0", 32, text_y + 30, 10, WHITE, BLACK);
 
-		BeginMode3D(camera);
-			DrawModelEx(Models["Ship"] ,Vector3Zero(), Vector3(.0f, 1.0f, .0f), this->ModelRotation, SCALE(1.0f), WHITE);
-		EndMode3D();
-
-		constexpr float text_y = 125.f;
-		UIUtils::GuiShadowText(("Rom Type: " + version.version).c_str(), 32, text_y, 10, WHITE, BLACK);
-		UIUtils::GuiShadowText("Tool Version: 1.0", 32, text_y + 15, 10, WHITE, BLACK);
-		UIUtils::GuiShadowText("OTR Version: 1.0", 32, text_y + 30, 10, WHITE, BLACK);
+	if (oldExtractMode)
 		UIUtils::GuiToggle(&single_thread, "Single Thread", 32, text_y + 40, currentStep != NULLSTR);
-		
-		if(!hide_second_btn && UIUtils::GuiIconButton("Folder", "Open\nShip Folder", 109, 50, currentStep != NULLSTR, "Select your Ship of Harkinian Folder\n\nYou could use another folder\nfor development purposes")) {
-			const std::string path = NativeFS->LaunchFileExplorer(LaunchType::FOLDER);
-			sohFolder = path;
-		}
 
-		if (UIUtils::GuiIconButton("Cartridge", "Open\nOoT Rom", 32, 50, currentStep != NULLSTR, "Select an Ocarina of Time\nMaster Quest or Vanilla Debug Rom\n\nYou can dump it or lend one from Nintendo")) {
-			const std::string path = NativeFS->LaunchFileExplorer(LaunchType::FILE);
-			if (path != NULLSTR) {
-				const std::string patched_n64 = std::string(patched_rom);
-				MoonUtils::rm(patched_n64);
-				version = GetVersion(fopen(path.c_str(), "r"));
-				if (version.version != NULLSTR) {
-					MoonUtils::copy(path, patched_n64);
-					rom_ready = true;
-					return;
-				}
-				fix_baserom(path.c_str(), patched_rom);
-				version = GetVersion(fopen(patched_rom, "r"));
-				if (version.version != NULLSTR) rom_ready = true;
+	if (!hide_second_btn && UIUtils::GuiIconButton("Folder", "Open\nShip Folder", 109, 50, currentStep != NULLSTR, "Select your Ship of Harkinian Folder\n\nYou could use another folder\nfor development purposes")) {
+		const std::string path = NativeFS->LaunchFileExplorer(LaunchType::FOLDER);
+		sohFolder = path;
+	}
+
+	if (UIUtils::GuiIconButton("Cartridge", "Open\nOoT Rom", 32, 50, currentStep != NULLSTR, "Select an Ocarina of Time\nGameCube PAL or Vanilla Debug Rom\n\nYou can dump it or lend one from Nintendo")) {
+		const std::string path = NativeFS->LaunchFileExplorer(LaunchType::FILE);
+		if (path != NULLSTR) {
+			const std::string patched_n64 = std::string(patched_rom);
+			MoonUtils::rm(patched_n64);
+			version = GetVersion(fopen(path.c_str(), "r"));
+			if (version.version != NULLSTR) {
+				MoonUtils::copy(path, patched_n64);
+				rom_ready = true;
+				return;
 			}
+			fix_baserom(path.c_str(), patched_rom);
+			version = GetVersion(fopen(patched_rom, "r"));
+			if (version.version != NULLSTR) rom_ready = true;
 		}
+	}
 
-		if(currentStep != NULLSTR) {
-			DrawRectangle(0, 0, windowSize.x, windowSize.y, Color(0, 0, 0, 160));
-			DrawTexture(Textures["Modal"], windowSize.x / 2 - Textures["Modal"].width / 2, windowSize.y / 2 - Textures["Modal"].height / 2, WHITE);
-			UIUtils::GuiShadowText(currentStep.c_str(), 0, windowSize.y / 2, 10, WHITE, BLACK, windowSize.x, true);
-		}
+	if (currentStep != NULLSTR) {
+		DrawRectangle(0, 0, windowSize.x, windowSize.y, Color(0, 0, 0, 160));
+		DrawTexture(Textures["Modal"], windowSize.x / 2 - Textures["Modal"].width / 2, windowSize.y / 2 - Textures["Modal"].height / 2, WHITE);
+		UIUtils::GuiShadowText(currentStep.c_str(), 0, windowSize.y / 2, 10, WHITE, BLACK, windowSize.x, true);
+	}
 
-    EndDrawing();
+	EndDrawing();
 }
 
 void setCurrentStep(const std::string& step) {
@@ -166,4 +220,4 @@ void setCurrentStep(const std::string& step) {
 
 void OTRGame::exit(){
 
-}
+}

OTRGui/src/game/game.h

@@ -19,6 +19,8 @@ public:
     void update();
     void draw();
     void exit();
+
+    inline bool CloseRequested() { return closeRequested; }
 protected:
     void LoadTexture(const std::string& name, const std::string& path) {
         const Image tmp = LoadImage(path.c_str());
@@ -32,6 +34,9 @@ protected:
         SetTextureFilter(font.texture, TEXTURE_FILTER_POINT);
         Fonts[name] = font;
     }
+
+private:
+    bool closeRequested = false;
 };
 
 extern OTRGame* Game;

OTRGui/src/impl/baserom_extractor/baserom_extractor.cpp

@@ -60,86 +60,103 @@ RomVersion GetVersion(FILE* rom) {
         version.version = "N64 NTSC 1.0";
         version.listPath = "ntsc_oot.txt";
         version.offset = OOT_OFF_NTSC_10;
+        version.isMQ = false;
         break;
     case OOT_NTSC_11:
         version.version = "N64 NTSC 1.1";
         version.listPath = "ntsc_oot.txt";
         version.offset = OOT_OFF_NTSC_11;
+        version.isMQ = false;
         break;
     case OOT_NTSC_12:
         version.version = "N64 NTSC 1.2";
         version.listPath = "ntsc_oot.txt";
         version.offset = OOT_OFF_NTSC_12;
+        version.isMQ = false;
         break;
     case OOT_PAL_10:
         version.version = "N64 PAL 1.0";
         version.listPath = "pal_oot.txt";
         version.offset = OOT_OFF_PAL_10;
+        version.isMQ = false;
         break;
     case OOT_PAL_11:
         version.version = "N64 PAL 1.1";
         version.listPath = "pal_oot.txt";
         version.offset = OOT_OFF_PAL_11;
+        version.isMQ = false;
         break;
     case OOT_NTSC_JP_GC:
         version.version = "JP GameCube (MQ Disk)";
-        version.listPath = "gamecube_mq.txt";
+        version.listPath = "gamecube.txt";
         version.offset = OOT_OFF_JP_GC;
+        version.isMQ = true;
         break;
     case OOT_NTSC_JP_GC_CE:
         version.version = "GameCube (Collectors Edition Disk)";
-        version.listPath = "gamecube_mq.txt";
+        version.listPath = "gamecube.txt";
         version.offset = OOT_OFF_JP_GC_CE;
+        version.isMQ = false;
         break;
     case OOT_NTSC_JP_MQ:
         version.version = "JP Master Quest";
-        version.listPath = "gamecube_mq.txt";
+        version.listPath = "gamecube.txt";
         version.offset = OOT_OFF_JP_MQ;
+        version.isMQ = true;
         break;
     case OOT_NTSC_US_MQ:
         version.version = "NTSC Master Quest";
-        version.listPath = "gamecube_mq.txt";
+        version.listPath = "gamecube.txt";
         version.offset = OOT_OFF_JP_MQ;
+        version.isMQ = true;
         break;
     case OOT_NTSC_US_GC:
         version.version = "NTSC GameCube";
-        version.listPath = "gamecube_mq.txt";
+        version.listPath = "gamecube.txt";
         version.offset = OOT_OFF_US_MQ;
+        version.isMQ = true;
         break;
     case OOT_PAL_GC:
         version.version = "PAL GameCube";
-        version.listPath = "gamecube_mq.txt";
+        version.listPath = "gamecube_pal.txt";
         version.offset = OOT_OFF_PAL_GC;
+        version.isMQ = false;
         break;
     case OOT_PAL_MQ:
         version.version = "PAL Master Quest";
-        version.listPath = "pal_mq.txt";
+        version.listPath = "gamecube_pal.txt";
         version.offset = OOT_OFF_PAL_MQ;
+        version.isMQ = true;
         break;
     case OOT_PAL_GC_DBG1:
         version.version = "GameCube Debug 1.0";
         version.listPath = "dbg.txt";
         version.offset = OOT_OFF_PAL_GC_DBG1;
+        version.isMQ = false;
         break;
     case OOT_PAL_GC_DBG2:
         version.version = "GameCube Debug 2.0";
         version.listPath = "dbg.txt";
         version.offset = OOT_OFF_PAL_GC_DBG2;
+        version.isMQ = false;
         break;
     case OOT_PAL_GC_MQ_DBG:
         version.version = "GameCube MQ-Debug";
         version.listPath = "dbg.txt";
         version.offset = OOT_OFF_PAL_MQ_DBG;
+        version.isMQ = true;
         break;
     case OOT_IQUE_CN:
         version.version = "OoT IQue";
         version.listPath = "ique.txt";
         version.offset = OOT_OFF_CN_IQUE;
+        version.isMQ = false;
         break;
     case OOT_IQUE_TW:
         version.version = "TW IQue";
         version.listPath = "ique.txt";
         version.offset = OOT_OFF_TW_IQUE;
+        version.isMQ = false;
         break;
     default:
         version.error = MoonUtils::format("Unknown CRC %x given: ", version.crc);
@@ -179,6 +196,8 @@ WriteResult ExtractBaserom(const char* romPath) {
 
     const std::vector<std::string> lines = MoonUtils::split(read(MoonUtils::join("assets/extractor/filelists", version.listPath)), '\n');
 
+    std::vector<uint8_t> decompressedData(1);
+
     for (int i = 0; i < lines.size(); i++) {
         FILE* outFile = fopen(MoonUtils::join("tmp/baserom", lines[i]).c_str(), "wb");
         const int romOffset = version.offset + (DMA_ENTRY_SIZE * i);
@@ -196,10 +215,13 @@ WriteResult ExtractBaserom(const char* romPath) {
         auto outData = new uint8_t[size];
         memcpy(outData, romData + physStart, size);
 
+
         if (compressed) {
-            std::vector<uint8_t> compressedData = yaz0_encode(outData, size);
-            outData = compressedData.data();
-            size = compressedData.size();
+            int decSize = virtEnd - virtStart;
+            decompressedData = std::vector<uint8_t>(decSize);
+            yaz0_decode(outData, decompressedData.data(), decSize);
+            outData = decompressedData.data();
+            size = decSize;
         }
 
         fwrite(outData, sizeof(char), size, outFile);

OTRGui/src/impl/baserom_extractor/baserom_extractor.h

@@ -1,23 +1,7 @@
 #ifndef EXTRACT_BASEROM_H_
 #define EXTRACT_BASEROM_H_
 
-#define OOT_NTSC_10 0xEC7011B7
-#define OOT_NTSC_11 0xD43DA81F
-#define OOT_NTSC_12 0x693BA2AE
-#define OOT_PAL_10 0xB044B569
-#define OOT_PAL_11 0xB2055FBD
-#define OOT_NTSC_JP_GC_CE 0xF7F52DB8
-#define OOT_NTSC_JP_GC 0xF611F4BA
-#define OOT_NTSC_US_GC 0xF3DD35BA
-#define OOT_PAL_GC 0x09465AC3
-#define OOT_NTSC_JP_MQ 0xF43B45BA
-#define OOT_NTSC_US_MQ 0xF034001A
-#define OOT_PAL_MQ 0x1D4136F3
-#define OOT_PAL_GC_DBG1 0x871E1C92 // 03-21-2002 build
-#define OOT_PAL_GC_DBG2 0x87121EFE // 03-13-2002 build
-#define OOT_PAL_GC_MQ_DBG 0x917D18F6
-#define OOT_IQUE_TW 0x3D81FB3E
-#define OOT_IQUE_CN 0xB1E1E07B
+#include "src/resource/GameVersions.h"
 #include <cstdio>
 #include <string>
 
@@ -25,6 +9,7 @@ struct RomVersion {
 	std::string version = "None";
 	std::string error = "None";
 	std::string listPath = "None";
+	bool isMQ;
 	int offset;
 	uint32_t crc;
 };

OTRGui/src/impl/extractor/extractor.cpp

@@ -5,6 +5,7 @@
 #include "utils/mutils.h"
 #include "ctpl/ctpl_stl.h"
 #include <thread>
+#include <impl/baserom_extractor/baserom_extractor.h>
 
 #ifdef _WIN32
 #define PLATFORM Platforms::WINDOWS
@@ -13,6 +14,7 @@
 #endif
 namespace Util = MoonUtils;
 
+bool oldExtractMode = false;
 static int maxResources = 0;
 static int extractedResources = 0;
 bool buildingOtr = false;
@@ -22,31 +24,53 @@ bool isWindows() {
 	return (PLATFORM == Platforms::WINDOWS);
 }
 
-void BuildOTR(const std::string output) {
-	Util::copy("tmp/baserom/Audiobank", "Extract/Audiobank");
-	Util::copy("tmp/baserom/Audioseq", "Extract/Audioseq");
-	Util::copy("tmp/baserom/Audiotable", "Extract/Audiotable");
-
-	Util::copy("assets/game/", "Extract/assets/");
-
-	std::string execStr = Util::format("assets/extractor/%s", isWindows() ? "ZAPD.exe" : "ZAPD.out") + " botr -se OTR";
-	ProcessResult result = NativeFS->LaunchProcess(execStr);
-	if(result.exitCode != 0) {
-		std::cout << "\nError when building the OTR file with error code: " << result.exitCode << " !" << std::endl;
-		std::cout << "Aborting...\n" << std::endl;
+std::string GetXMLVersion(RomVersion version)
+{
+	switch (version.crc)
+	{
+	case OOT_PAL_GC_DBG1: return "GC_NMQ_D";
+	case OOT_PAL_GC_MQ_DBG: return "GC_MQ_D";
+	case OOT_PAL_GC:	  return "GC_NMQ_PAL_F";
 	}
-	setCurrentStep("Done!");
 
-	if (output == ".") return;
-	const std::string outputPath = MoonUtils::join(output, "oot.otr");
-	if(MoonUtils::exists(outputPath)) MoonUtils::rm(outputPath);
-
-	MoonUtils::copy("oot.otr", outputPath);
+	return "ERROR";
 }
 
-void ExtractFile(std::string xmlPath, std::string outPath, std::string outSrcPath) {
+void BuildOTR(const std::string output, RomVersion version) {
+	if (oldExtractMode)
+	{
+		std::string execStr = Util::format("assets/extractor/%s", isWindows() ? "ZAPD.exe" : "ZAPD.out") + " botr -se OTR";
+		ProcessResult result = NativeFS->LaunchProcess(execStr);
+		if (result.exitCode != 0) {
+			std::cout << "\nError when building the OTR file with error code: " << result.exitCode << " !" << std::endl;
+			std::cout << "Aborting...\n" << std::endl;
+		}
+	}
+
+	setCurrentStep("Done!");
+
+	// If a custom SoH folder was not selected, or the custom SOH folder is the same location as OTRGui,
+	// then the otr file should already be where it is expected
+	if (output == "." || output == MoonUtils::absolute(".")) {
+		return;
+	}
+
+	// Otherwise an outside SoH folder was selected so we need to copy the exported otr to the correct folder
+	const std::string otrName = version.isMQ ? "oot-mq.otr" : "oot.otr";
+	const std::string outputPath = MoonUtils::join(output, otrName);
+	if (MoonUtils::exists(outputPath)) MoonUtils::rm(outputPath);
+
+	MoonUtils::copy(otrName, outputPath);
+}
+
+void ExtractFile(std::string xmlPath, std::string outPath, std::string outSrcPath, RomVersion version) {
+	std::string otrExporterArgs = Util::format("--otrfile %s", version.isMQ ? "oot-mq.otr" : "oot.otr");
+	if (xmlPath.find("overlays") != std::string::npos) {
+		otrExporterArgs += " --static";
+	}
+
 	std::string execStr = Util::format("assets/extractor/%s", isWindows() ? "ZAPD.exe" : "ZAPD.out");
-	std::string args = Util::format(" e -eh -i %s -b tmp/baserom/ -o %s -osf %s -gsf 1 -rconf assets/extractor/Config.xml -se OTR %s", xmlPath.c_str(), outPath.c_str(), outSrcPath.c_str(), xmlPath.find("overlays") != std::string::npos ? "--static" : "");
+	std::string args = Util::format(" e -eh -i %s -b tmp/baserom/ -o %s -osf %s -gsf 1 -rconf assets/extractor/Config_%s.xml -se OTR %s", xmlPath.c_str(), outPath.c_str(), outSrcPath.c_str(), GetXMLVersion(version).c_str(), otrExporterArgs);
 	ProcessResult result = NativeFS->LaunchProcess(execStr + args);
 
 	if (result.exitCode != 0) {
@@ -55,53 +79,82 @@ void ExtractFile(std::string xmlPath, std::string outPath, std::string outSrcPat
 	}
 }
 
-void ExtractFunc(std::string fullPath) {
+void ExtractFunc(std::string fullPath, RomVersion version) {
 	std::vector<std::string> path = Util::split(fullPath, Util::pathSeparator());
 	std::string outPath = Util::join(Util::join("assets/extractor/xmls/output", path[4]), Util::basename(fullPath));
 	Util::mkdir(outPath);
-	ExtractFile(fullPath, outPath, outPath);
+	ExtractFile(fullPath, outPath, outPath, version);
 	setCurrentStep("Extracting: " + Util::basename(fullPath));
 	extractedResources++;
 }
 
-void startWorker() {
-	std::string path = "assets/extractor/xmls";
-	std::vector<std::string> files;
-	Util::dirscan(path, files);
-	std::vector<std::string> xmlFiles;
+void startWorker(RomVersion version) {
+	std::string path = "assets/extractor/xmls/";
 
-	const int num_threads = std::thread::hardware_concurrency();
-	ctpl::thread_pool pool(num_threads / 2);
-	for(auto &file : files) {
-		if (file.find(".xml") != std::string::npos) xmlFiles.push_back(file);
-	}
+	path += GetXMLVersion(version);
 
-	for (auto& file : xmlFiles) {
-		if(single_thread) {
-			ExtractFunc(file);
-		} else {
-			pool.push([file](int) {
-				ExtractFunc(file);
-			});
+	// Util::write("tmp/baserom/version", (char*)&version.crc, sizeof(version.crc));
+
+	if (oldExtractMode)
+	{
+		std::vector<std::string> files;
+		Util::dirscan(path, files);
+		std::vector<std::string> xmlFiles;
+
+		const int num_threads = std::thread::hardware_concurrency();
+		ctpl::thread_pool pool(num_threads / 2);
+		for (auto& file : files) {
+			if (file.find(".xml") != std::string::npos) xmlFiles.push_back(file);
 		}
-	}
 
-	maxResources = xmlFiles.size();
+		for (auto& file : xmlFiles) {
+			if (single_thread) {
+				ExtractFunc(file, version);
+			}
+			else {
+				pool.push([file, version](int) {
+					ExtractFunc(file, version);
+					});
+			}
+		}
+
+		maxResources = xmlFiles.size();
+	}
+	else
+	{
+		std::string otrExporterArgs = Util::format("--otrfile %s", version.isMQ ? "oot-mq.otr" : "oot.otr");
+		std::string execStr = Util::format("assets/extractor/%s", isWindows() ? "ZAPD.exe" : "ZAPD.out");
+		std::string args = Util::format(" ed -eh -i %s -b tmp/rom.z64 -fl assets/extractor/filelists -o %s -osf %s -gsf 1 -rconf assets/extractor/Config_%s.xml -se OTR %s", path.c_str(), (path + "/../").c_str(), (path + "/../").c_str(), GetXMLVersion(version).c_str(), otrExporterArgs.c_str());
+		ProcessResult result = NativeFS->LaunchProcess(execStr + args);
+
+		if (result.exitCode != 0) {
+			std::cout << "\nError when extracting the ROM with error code: " << result.exitCode << " !" << std::endl;
+			std::cout << "Aborting...\n" << std::endl;
+		}
+		else
+		{
+			printf("All done?\n");
+		}
+
+		maxResources = 1;
+	}
 }
 
-void updateWorker(const std::string& output) {
-	if (maxResources > 0 && !buildingOtr && extractedResources >= maxResources) {
+void updateWorker(const std::string& output, RomVersion version) {
+	if (maxResources > 0 && !buildingOtr && (extractedResources >= maxResources || !oldExtractMode)) 
+	{
 		setCurrentStep("Building OTR...");
 		if (skipFrames < 3) {
 			skipFrames++;
 			return;
 		}
 		buildingOtr = true;
-		if (single_thread){
-			BuildOTR(output);
+		
+		if (single_thread || !oldExtractMode){
+			BuildOTR(output, version);
 			return;
 		}
-		std::thread otr(BuildOTR, output);
+		std::thread otr(BuildOTR, output, version);
 		otr.detach();
 	}
-}
+}

OTRGui/src/impl/extractor/extractor.h

@@ -5,5 +5,7 @@ enum Platforms {
 	WINDOWS, LINUX
 };
 
-void startWorker();
-void updateWorker(const std::string& output);
+struct RomVersion;
+
+void startWorker(RomVersion version);
+void updateWorker(const std::string& output, RomVersion version);

OTRGui/src/main.cpp

@@ -17,8 +17,8 @@ void UpdateDrawFrame(void) {
 }
 
 int main() {
-	constexpr Vector2 windowSize = Vector2(400, 200);
-    SetTargetFPS(144);
+    constexpr Vector2 windowSize = Vector2(400, 200);
+    SetConfigFlags(FLAG_VSYNC_HINT);
     SetConfigFlags(FLAG_WINDOW_HIGHDPI);
     SetConfigFlags(FLAG_WINDOW_UNDECORATED);
     SetConfigFlags(FLAG_MSAA_4X_HINT);
@@ -32,7 +32,7 @@ int main() {
     Game = new OTRGame();
     Game->preload();
     Game->init();
-    while(!WindowShouldClose()) {
+    while(!WindowShouldClose() && !Game->CloseRequested()) {
         UpdateDrawFrame();
     }
     CloseWindow();

OTRGui/src/utils/mutils.cpp

@@ -72,7 +72,11 @@ namespace MoonUtils {
         vector<string> result;
         stringstream ss (s);
         string item;
-        while (getline(ss, item, delim)) {
+        while (getline(ss, item, delim)) 
+        {
+            if (item.at(item.size() - 1) == '\r')
+                item = item.substr(0, item.size() - 1);
+
             result.push_back (item);
         }
         return result;
@@ -98,6 +102,10 @@ namespace MoonUtils {
         else fs::remove(path);
     }
 
+    string absolute(string path) {
+        return normalize(fs::absolute(path).string());
+    }
+
     string relative(string parent, string child){
         return normalize(fs::relative(child, parent).string());
     }

OTRGui/src/utils/mutils.h

@@ -37,6 +37,7 @@ namespace MoonUtils {
     bool exists(std::string path);
     void mkdir(std::string path);
     void rm(std::string path);
+    std::string absolute(std::string path);
     std::string relative(std::string parent, std::string child);
     void move(std::string src, std::string dst);
     void copy(std::string src, std::string dst);

README.md

@@ -4,27 +4,48 @@ A PC port of OoT allowing you to enjoy the game with modern controls, widescreen
 
 The Ship does not include assets and as such requires a prior copy of the game to play.
 
-## Quick Start
+## Discord
 
-1) Download [The Ship of Harkinian](https://github.com/HarbourMasters/Shipwright/releases/latest) from releases.
-2) Get a ZRET OoT Debug ROM
-```
-Build date: `zelda@srd022j 03-02-21 00:49:18`
-sha1: cee6bc3c2a634b41728f2af8da54d9bf8cc14099
-```
+Official Discord: https://discord.com/invite/BtBmd55HVH
+
+## Quick Start (Windows)
+
+1) Download The Ship of Harkinian from [Discord](https://discord.com/invite/BtBmd55HVH).
+2) Requires a supported copy of the game (See supported games below).
 3) Use the OTRGui to generate an `oot.otr` archive file.
 4) Launch `soh.exe`
 
+### Supported Games
+#### Ocarina of Time Debug PAL GC (not Master Quest)
+> Currently the recommended option
+```
+Build team: `zelda@srd022j`
+Build date: `03-02-21 00:49:18` (year-month-day)
+sha1: cee6bc3c2a634b41728f2af8da54d9bf8cc14099
+```
+#### Ocarina of Time PAL GameCube
+> May lead to crashes and instability
+```
+sha1: 0227d7c0074f2d0ac935631990da8ec5914597b4
+```
+#### Ocarina of Time Debug PAL GC MQ (Dungeons will be Master Quest)
+```
+Build team: `zelda@srd022j`
+Build date: `03-02-21 00:16:31` (year-month-day)
+sha1: 079b855b943d6ad8bd1eb026c0ed169ecbdac7da (Produced by decomp)
+sha1: 50bebedad9e0f10746a52b07239e47fa6c284d03 (Alternate)
+```
+
 Congratulations, you are now sailing with the Ship of Harkinian! Have fun!
 
 ## Additional Setup Information
 
 The Ship of Harkinian uses a proprietary versioning system consisting of a sci-fi film character followed by a phonetic alphabet code word. The film character represents a major release version which increments with the addition of many new features and bug fixes. The code word represents a minor release version which increments with small updates mainly comprised of bug fixes. For example, `DECKARD ALFA`.
 
-### The Extraction Tool
+### Windows Rom Extraction
 
-* Open a rom to initiate generating the `oot.otr` archive file.
-* If a second button exists then `oot.otr` already exists. To prevent overwriting the old `oot.otr` use this button to choose a new game directory. The new directory must not already contain an `oot.otr` to prevent an error.
+* Open OTRGui.exe, and select one of the supported roms listed above, to generate the `oot.otr` archive file.
+* If a second button already exits then `oot.otr` already exists. To prevent overwriting the old `oot.otr` use this button to choose a new game directory. The new directory must not already contain an `oot.otr` to prevent an error.
 * When the process completes, place `oot.otr` beside `soh.exe` if it is not already.
 
 This packaging process can take up to **5 minutes**.
@@ -32,81 +53,139 @@ This packaging process can take up to **5 minutes**.
 Close the OTRGui when the `Done!` message appears.
 If you get another message, then you might have selected the wrong rom. Make sure to use a rom consistent with the above checksum.
 
+### Linux Rom Extraction
+
+* Place one of the supported roms in the same folder as the appimage.
+* When you run the soh appimage, it should begin generating the `oot.otr` archive file.
+* When the process completes, place `oot.otr` in the same folder as the appimage, if it is not already, then run the appimage.
+
+The packaging process can take up to **5 minutes**.
+
+If you get any errors, then you might have selected the wrong rom. Make sure to use a rom consistent with the above checksum.
+
+### MacOS Rom Extraction
+
+* Run `soh.app`, and when prompted, select one of the supported roms listed above.
+* You should see a notification saying `Processing OTR`, then, once the process is complete, you should get a notification saying `OTR Successfully Generated`, then the game should start.
+
+The packing process can take up to **5 minutes**.
+
+If you get an error saying `Incompatible ROM hash`, you have selected the wrong rom, make sure the checksum matches one of the ones listed above.
+
+### Nintendo Switch Rom Extraction
+
+* Download the latest PC release of the Ship of Harkinian, and follow the instructions above for generating the `oot.otr` archive on that platform.
+* Place the `.nro` and the `oot.otr` archive into a folder called `soh` in your Switch folder on your Switch
+
+### Nintendo Wii U Rom Extraction
+
+* Download the latest PC release of the Ship of Harkinian, and follow the instructions above for generating the `oot.otr` archive on that platform.
+* Copy the `.rpx` and the `oot.otr` archive to `wiiu/apps/soh`
+
+---
+
 If you still cannot get the tool to work, join our [Discord Server](https://discord.com/invite/BtBmd55HVH) and ask for help in the `#support` text channel. Keep-in-mind that we do not condone piracy in any way.
 
 ### Running The Ship of Harkinian
 
-Launch the game. If the window immediately closes, or if there are visual artifacts, you may have selected the wrong rom in the OTRGui tool. 
+Launch the game. If the window immediately closes, or if there are visual artifacts, you may have selected the wrong rom in the OTRGui tool.
 
-Currently, DirectX 11 and OpenGL is supported. Change the renderer by opening the `shipofharkinian.ini` configuration file in notepad and add `sdl` to `gfx backend` for OpenGL or leave blank for DirectX.
+Default keyboard configuration:
+| N64 | A | B | Z | Start | Analog stick | C buttons | D-Pad |
+| - | - | - | - | - | - | - | - |
+| Keyboard | X | C | Z | Space | WASD | Arrow keys | TFGH |
+
+Other shortcuts:
+| Keys | Action |
+| - | - |
+| F1 | Toggle menubar |
+| F5 | Save state |
+| F6 | Change state |
+| F7 | Load state |
+| F10 | Fullscreen (OpenGL) |
+| Alt+Enter | Fullscreen (DirectX) |
+| Ctrl+R | Reset |
+
+Currently, DirectX 11 and OpenGL are supported. Change the renderer by opening the `shipofharkinian.json` configuration file in notepad and add `sdl` to the quotes in `"GfxBackend": ""` for OpenGL or leave blank for DirectX.
+
+### Custom Music
+
+We support importing custom [Seq64](https://github.com/sauraen/seq64) files to replace the in game music and fanfares (Not sound effects yet currently).
+
+First you will need to prepare a folder with the desired sequences, in which every sequence will have two files with the same name and different extensions, a `.seq` Seq64 file and a `.meta` plaintext file. These files can be categorically nested in folders if desired, they will still be consumed as if they were all at the top level.
+
+The meta file will have two lines, the first line is the name that will be displayed in the SFX editor, and the second line will be the instrument set number, in base 16. For example, if there is a sequence file `Foo.seq` then you need a meta file `Foo.meta` that could contain:
+```
+Awesome Name
+C
+```
+
+Once you have prepared your sequences folder:
+1. Download and open [Retro](https://github.com/HarbourMasters/retro/releases). 
+1. Choose the "Create OTR" option 
+1. Choose the "Custom Sequences" option
+1. Using the file select, choose the sequences folder you prepared in the previous instructions.
+1. Click the "Stage Files" button (Reminder: SoH can handle 1024 custom sequence in total, this number include the count of the original music with it so be sure to take this into account)
+1. Click the "Finalize OTR" text in the green footer.
+1. Finally click "Generate OTR" and for the source destination it needs to go in the `mods` folder of your SoH installation.
+    - This `mods` folder should be a sibling of your `oot.otr` file.
+
+Assuming you have done everything correctly, boot up SoH and open up the SFX Editor (In the Enhancements dropdown). You should now be able to swap out any of the in game sequences/fanfares for the sequences added in your newly generated OTR file. If you have any trouble with this process please reach out in the support section of the Discord
+
+## Building The Ship of Harkinian
+
+Refer to the [building instructions](BUILDING.md) to compile SoH.
+
+## Nightly Builds
+Nightly builds of Ship of Harkinian are available here: [Windows](https://nightly.link/HarbourMasters/Shipwright/workflows/generate-builds/develop/soh-windows.zip), [macOS](https://nightly.link/HarbourMasters/Shipwright/workflows/generate-builds/develop/soh-mac.zip), [Linux (compatibility*)](https://nightly.link/HarbourMasters/Shipwright/workflows/generate-builds/develop/soh-linux-compatiblity.zip), [Linux (performance*)](https://nightly.link/HarbourMasters/Shipwright/workflows/generate-builds/develop/soh-linux-performance.zip), [Switch](https://nightly.link/HarbourMasters/Shipwright/workflows/generate-builds/develop/soh-switch.zip), [Wii U](https://nightly.link/HarbourMasters/Shipwright/workflows/generate-builds/develop/soh-wiiu.zip)
+
+_*compatibility: compatible with most Linux distributions, but may not be as performant as the perf build._\
+_*performance: requires glibc 2.35 or newer, but will be more performant than the compat build._
 
 ## Take The Survey
 Want to use cartridge readers in tandem with the OTRGui?
 Take [this survey](https://retroarchopenhardware.com/survey.php) to increase chances of this becoming reality.
 
-## Discord
-
-Official Discord: https://discord.com/invite/BtBmd55HVH
-
-## Building The Ship of Harkinian
-
- 1. Install [Python](https://www.python.org/ftp/python/3.10.2/python-3.10.2-amd64.exe)
- 2. Install [Visual Studio 2022 Community Edition](https://visualstudio.microsoft.com/vs/community/)
- 2b. In the Visual Studio Installer, install `MSVC v142 - VS 2019 C++`.
- 4. Clone the Ship of Harkinian repository.
- 5. Put your 2020 OoT debug rom in the `soh` folder.
- 6. Launch `soh/fixbaserom.py`.
- 7. Launch `soh/extract_baserom.py`.
- 8. Copy the `baserom` folder from the `soh` folder into the `OTRExporter` folder.
- 9. Run `OTRExporter/OTRExporter.sln`.
- 10. Switch the solution to `Release x64`.
- 11. Build the solution. 
- 12. Launching `OTRExporter/extract_assets.py` will generate an `oot.otr` archive file in `OTRExporter/oot.otr`.
- 13. Run `soh/soh.sln`
- 14. Switch the solution to `Release x86`.
- 15. Build the solution.
- 16. Copy the `OTRExporter/oot.otr` archive file to `soh/Release`.
- 17. Launch `soh.exe`.
-
-## Troubleshooting The Exporter
-- Affirm that you have an `/assets` folder filled with XMLs in the same directory as OTRGui.exe
-- Affirm that `zapd.exe` exists in the `/assets/extractor` folder
-
-
 ## The Harbour Masters Are...
 
-    Kenix 			| Lead Developer/Public Relations - Resource Management Programmer, Audio System Programmer, and General Programmer
-    Jack Walker 		| Lead Developer - OTR Format Programmer, Resource Load Programmer, and General Programmer
-    Louist103 		| Developer - Save System Programmer and General Programmer
-    Emil 			| Developer - Fast3D Programmer
-    m4xw 			| Developer - Shipwright, Throwing Baguettes, and General Programmer
-    MelonSpeedruns 		| Developer - General Programmer
-    Rozlette 		| Developer - General Programmer
-    JoshDuMan 		| Developer - General Programmer
-    KiritoDev/Lywx 		| Developer - General Programmer
-    Theo3 			| Developer - General Programmer
-	Random06457  		| Developer - Linux Build
+    Kenix | Lead Developer/Public Relations - Resource Management Programmer, Audio System Programmer, and General Programmer
+    Jack Walker | Lead Developer - OTR Format Programmer, Resource Load Programmer, and General Programmer
+    Louist103 | Developer - Save System Programmer and General Programmer
+    Emil | Developer - Fast3D Programmer
+    m4xw | Developer - Shipwright, Throwing Baguettes, and General Programmer
+    MelonSpeedruns | Developer - General Programmer
+    Rozlette | Developer - General Programmer
+    JoshDuMan | Developer - General Programmer
+    KiritoDev/Lywx | Developer - General Programmer
+    Theo3 | Developer - General Programmer
+	Random06457 | Developer - Linux Build
 
 ## Special Thanks
 
-    Decomp & ZAPD 		| Made this project even possible in the first place!
-    MNGoldenEagle 		| Patiently explained audio data formats, encouragement, and founding ZSO which was the first source of the game's code and resource format documentation.
-    Rrrrry123 		| Speedbunner, encouragement, and community moderation
-    Fierce deity 		| Encouragement and community moderation
-    mzxrules		| For his contributions to decomp
-    Aloxado 		| Developer - General Programmer
-    MegaMech 		| Developer - General Programmer
-	Revo 			| Tester - GCC support and General Testing
-	zfg 			| Tester - General Testing
-	Horseless Headman 	| Tester - General Testing
-    Steven Pritchett        | Tester - General Testing
-	Trenton May 		| Tester - General Testing
-	Zeldaboy14 		| Tester - General Testing, encouragement, and community moderation
-	Koby Howell 		| Tester - General Testing
-	Logg 			| Tester - General Testing
-	Taylor Daley		| Graphic Design
-	Can't Sleep 		| Graphic Design
-    MicTheMicrophone 	| Voice actor for the King
-    Amphibibro		| Voice actor for Link
-
-Lemons
+    Decomp & ZAPD | Made this project even possible in the first place!
+    MNGoldenEagle | Patiently explained audio data formats, encouragement, and founding ZSO which was the first source of the game's code and resource format documentation.
+    Rrrrry123 | Speedbunner, encouragement, and community moderation
+    Fierce deity | Encouragement and community moderation
+    mzxrules | For his contributions to decomp
+    zel. | For his contributions to decomp
+    Aloxado | Developer - General Programmer
+    MegaMech | Developer - General Programmer
+	Revo | Tester - GCC support and General Testing
+	zfg | Tester - General Testing
+	Horseless Headman | Tester - General Testing
+    Steven Pritchett | Tester - General Testing
+	Trenton May | Tester - General Testing
+	Zeldaboy14 | Tester - General Testing, encouragement, and community moderation
+	Koby Howell | Tester - General Testing
+	Logg | Tester - General Testing
+	Taylor Daley | Graphic Design
+	Can't Sleep | Graphic Design
+	
+## Video Credits
+    Kenix | Producer / Writer
+    briaguya | Writer
+    rainbow_fash | Executive Producer
+    ReveriePass | Editor
+    MicTheMicrophone | Gwonam / The King
+    Amphibibro | Link
+    AceHeart | Zelda

ZAPDTR/.gitrepo

@@ -6,7 +6,7 @@
 [subrepo]
 	remote = https://github.com/HarbourMasters/ZAPDTR.git
 	branch = master
-	commit = a53a53ea4216b926253dde2c942ae0ca6e2f2ccd
-	parent = f52a2a6406eb1bbd2b631c65923d879a83983ccb
+	commit = e23b125d89bd973998d2eb00896bcbaf1b53a329
+	parent = 17b1a8e7fd5517f9232e531da0fed6ef80a87f04
 	method = rebase
-	cmdver = 0.4.1
+	cmdver = 0.4.3

ZAPDTR/ExporterTest/CollisionExporter.cpp

@@ -1,6 +1,6 @@
 #include "CollisionExporter.h"
 
-void ExporterExample_Collision::Save(ZResource* res, [[maybe_unused]] fs::path outPath,
+void ExporterExample_Collision::Save(ZResource* res, [[maybe_unused]] const fs::path& outPath,
                                      BinaryWriter* writer)
 {
 	ZCollisionHeader* col = (ZCollisionHeader*)res;

ZAPDTR/ExporterTest/CollisionExporter.h

@@ -6,5 +6,5 @@
 class ExporterExample_Collision : public ZResourceExporter
 {
 public:
-	void Save(ZResource* res, fs::path outPath, BinaryWriter* writer) override;
+	void Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer) override;
 };