From 442a88f03bcb406dfcf693b4948412ab10d2cf08 Mon Sep 17 00:00:00 2001 From: M4xw Date: Tue, 22 Mar 2022 02:53:02 +0100 Subject: [PATCH] git subrepo clone https://github.com/HarbourMasters/OTRExporter.git subrepo: subdir: "OTRExporter" merged: "1503d3eef" upstream: origin: "https://github.com/HarbourMasters/OTRExporter.git" branch: "master" commit: "1503d3eef" git-subrepo: version: "0.4.1" origin: "???" commit: "???" --- OTRExporter/.gitignore | 350 +++++++ OTRExporter/.gitrepo | 12 + OTRExporter/CFG/ActorList_OoTMqDbg.txt | 472 +++++++++ OTRExporter/CFG/Config.xml | 8 + OTRExporter/CFG/ObjectList_OoTMqDbg.txt | 402 ++++++++ OTRExporter/CFG/SymbolMap_OoTMqDbg.txt | 1 + OTRExporter/CFG/TexturePool.xml | 952 +++++++++++++++++ OTRExporter/LICENSE | 9 + OTRExporter/OTRExporter.sln | 68 ++ OTRExporter/OTRExporter/AnimationExporter.cpp | 70 ++ OTRExporter/OTRExporter/AnimationExporter.h | 13 + OTRExporter/OTRExporter/ArrayExporter.cpp | 104 ++ OTRExporter/OTRExporter/ArrayExporter.h | 12 + .../OTRExporter/BackgroundExporter.cpp | 10 + OTRExporter/OTRExporter/BackgroundExporter.h | 12 + OTRExporter/OTRExporter/BlobExporter.cpp | 21 + OTRExporter/OTRExporter/BlobExporter.h | 12 + OTRExporter/OTRExporter/CollisionExporter.cpp | 82 ++ OTRExporter/OTRExporter/CollisionExporter.h | 11 + OTRExporter/OTRExporter/CutsceneExporter.cpp | 431 ++++++++ OTRExporter/OTRExporter/CutsceneExporter.h | 11 + .../OTRExporter/DisplayListExporter.cpp | 973 ++++++++++++++++++ OTRExporter/OTRExporter/DisplayListExporter.h | 17 + OTRExporter/OTRExporter/Exporter.cpp | 20 + OTRExporter/OTRExporter/Exporter.h | 12 + OTRExporter/OTRExporter/Main.cpp | 183 ++++ OTRExporter/OTRExporter/Main.h | 5 + OTRExporter/OTRExporter/Makefile | 70 ++ OTRExporter/OTRExporter/MtxExporter.cpp | 13 + OTRExporter/OTRExporter/MtxExporter.h | 10 + OTRExporter/OTRExporter/OTRExporter.vcxproj | 202 ++++ .../OTRExporter/OTRExporter.vcxproj.filters | 144 +++ OTRExporter/OTRExporter/PathExporter.cpp | 23 + OTRExporter/OTRExporter/PathExporter.h | 12 + .../OTRExporter/PlayerAnimationExporter.cpp | 21 + .../OTRExporter/PlayerAnimationExporter.h | 13 + OTRExporter/OTRExporter/RoomExporter.cpp | 530 ++++++++++ OTRExporter/OTRExporter/RoomExporter.h | 14 + OTRExporter/OTRExporter/SkeletonExporter.cpp | 39 + OTRExporter/OTRExporter/SkeletonExporter.h | 14 + .../OTRExporter/SkeletonLimbExporter.cpp | 176 ++++ .../OTRExporter/SkeletonLimbExporter.h | 15 + OTRExporter/OTRExporter/TextExporter.cpp | 19 + OTRExporter/OTRExporter/TextExporter.h | 12 + OTRExporter/OTRExporter/TextureExporter.cpp | 31 + OTRExporter/OTRExporter/TextureExporter.h | 12 + OTRExporter/OTRExporter/VersionInfo.cpp | 25 + OTRExporter/OTRExporter/VersionInfo.h | 9 + OTRExporter/OTRExporter/VtxExporter.cpp | 44 + OTRExporter/OTRExporter/VtxExporter.h | 13 + OTRExporter/OTRExporter/command_macros_base.h | 36 + OTRExporter/OTRExporter/z64cutscene.h | 290 ++++++ .../OTRExporter/z64cutscene_commands.h | 448 ++++++++ .../assets/ship_of_harkinian/buttons/ABtn.png | Bin 0 -> 10967 bytes .../assets/ship_of_harkinian/buttons/BBtn.png | Bin 0 -> 1300 bytes .../ship_of_harkinian/buttons/CDown.png | Bin 0 -> 11241 bytes .../ship_of_harkinian/buttons/CLeft.png | Bin 0 -> 11232 bytes .../ship_of_harkinian/buttons/CRight.png | Bin 0 -> 11284 bytes .../assets/ship_of_harkinian/buttons/CUp.png | Bin 0 -> 11219 bytes .../assets/ship_of_harkinian/buttons/LBtn.png | Bin 0 -> 355 bytes .../assets/ship_of_harkinian/buttons/RBtn.png | Bin 0 -> 379 bytes .../ship_of_harkinian/buttons/StartBtn.png | Bin 0 -> 11868 bytes .../assets/ship_of_harkinian/buttons/ZBtn.png | Bin 0 -> 1241 bytes .../ship_of_harkinian/icons/gSohIcon.png | Bin 0 -> 2355 bytes OTRExporter/extract_assets.py | 117 +++ OTRExporter/offsets.json | 8 + 66 files changed, 6633 insertions(+) create mode 100644 OTRExporter/.gitignore create mode 100644 OTRExporter/.gitrepo create mode 100644 OTRExporter/CFG/ActorList_OoTMqDbg.txt create mode 100644 OTRExporter/CFG/Config.xml create mode 100644 OTRExporter/CFG/ObjectList_OoTMqDbg.txt create mode 100644 OTRExporter/CFG/SymbolMap_OoTMqDbg.txt create mode 100644 OTRExporter/CFG/TexturePool.xml create mode 100644 OTRExporter/LICENSE create mode 100644 OTRExporter/OTRExporter.sln create mode 100644 OTRExporter/OTRExporter/AnimationExporter.cpp create mode 100644 OTRExporter/OTRExporter/AnimationExporter.h create mode 100644 OTRExporter/OTRExporter/ArrayExporter.cpp create mode 100644 OTRExporter/OTRExporter/ArrayExporter.h create mode 100644 OTRExporter/OTRExporter/BackgroundExporter.cpp create mode 100644 OTRExporter/OTRExporter/BackgroundExporter.h create mode 100644 OTRExporter/OTRExporter/BlobExporter.cpp create mode 100644 OTRExporter/OTRExporter/BlobExporter.h create mode 100644 OTRExporter/OTRExporter/CollisionExporter.cpp create mode 100644 OTRExporter/OTRExporter/CollisionExporter.h create mode 100644 OTRExporter/OTRExporter/CutsceneExporter.cpp create mode 100644 OTRExporter/OTRExporter/CutsceneExporter.h create mode 100644 OTRExporter/OTRExporter/DisplayListExporter.cpp create mode 100644 OTRExporter/OTRExporter/DisplayListExporter.h create mode 100644 OTRExporter/OTRExporter/Exporter.cpp create mode 100644 OTRExporter/OTRExporter/Exporter.h create mode 100644 OTRExporter/OTRExporter/Main.cpp create mode 100644 OTRExporter/OTRExporter/Main.h create mode 100644 OTRExporter/OTRExporter/Makefile create mode 100644 OTRExporter/OTRExporter/MtxExporter.cpp create mode 100644 OTRExporter/OTRExporter/MtxExporter.h create mode 100644 OTRExporter/OTRExporter/OTRExporter.vcxproj create mode 100644 OTRExporter/OTRExporter/OTRExporter.vcxproj.filters create mode 100644 OTRExporter/OTRExporter/PathExporter.cpp create mode 100644 OTRExporter/OTRExporter/PathExporter.h create mode 100644 OTRExporter/OTRExporter/PlayerAnimationExporter.cpp create mode 100644 OTRExporter/OTRExporter/PlayerAnimationExporter.h create mode 100644 OTRExporter/OTRExporter/RoomExporter.cpp create mode 100644 OTRExporter/OTRExporter/RoomExporter.h create mode 100644 OTRExporter/OTRExporter/SkeletonExporter.cpp create mode 100644 OTRExporter/OTRExporter/SkeletonExporter.h create mode 100644 OTRExporter/OTRExporter/SkeletonLimbExporter.cpp create mode 100644 OTRExporter/OTRExporter/SkeletonLimbExporter.h create mode 100644 OTRExporter/OTRExporter/TextExporter.cpp create mode 100644 OTRExporter/OTRExporter/TextExporter.h create mode 100644 OTRExporter/OTRExporter/TextureExporter.cpp create mode 100644 OTRExporter/OTRExporter/TextureExporter.h create mode 100644 OTRExporter/OTRExporter/VersionInfo.cpp create mode 100644 OTRExporter/OTRExporter/VersionInfo.h create mode 100644 OTRExporter/OTRExporter/VtxExporter.cpp create mode 100644 OTRExporter/OTRExporter/VtxExporter.h create mode 100644 OTRExporter/OTRExporter/command_macros_base.h create mode 100644 OTRExporter/OTRExporter/z64cutscene.h create mode 100644 OTRExporter/OTRExporter/z64cutscene_commands.h create mode 100644 OTRExporter/assets/ship_of_harkinian/buttons/ABtn.png create mode 100644 OTRExporter/assets/ship_of_harkinian/buttons/BBtn.png create mode 100644 OTRExporter/assets/ship_of_harkinian/buttons/CDown.png create mode 100644 OTRExporter/assets/ship_of_harkinian/buttons/CLeft.png create mode 100644 OTRExporter/assets/ship_of_harkinian/buttons/CRight.png create mode 100644 OTRExporter/assets/ship_of_harkinian/buttons/CUp.png create mode 100644 OTRExporter/assets/ship_of_harkinian/buttons/LBtn.png create mode 100644 OTRExporter/assets/ship_of_harkinian/buttons/RBtn.png create mode 100644 OTRExporter/assets/ship_of_harkinian/buttons/StartBtn.png create mode 100644 OTRExporter/assets/ship_of_harkinian/buttons/ZBtn.png create mode 100644 OTRExporter/assets/ship_of_harkinian/icons/gSohIcon.png create mode 100755 OTRExporter/extract_assets.py create mode 100644 OTRExporter/offsets.json diff --git a/OTRExporter/.gitignore b/OTRExporter/.gitignore new file mode 100644 index 000000000..2372a0cba --- /dev/null +++ b/OTRExporter/.gitignore @@ -0,0 +1,350 @@ +## 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/ +ZAPDUtils/build/ +ZAPD/BuildInfo.h +baserom/ +*.vtx.inc +*.otr +*.swp +*.a +Extract/ + +tmp.txt diff --git a/OTRExporter/.gitrepo b/OTRExporter/.gitrepo new file mode 100644 index 000000000..80e147d0c --- /dev/null +++ b/OTRExporter/.gitrepo @@ -0,0 +1,12 @@ +; DO NOT EDIT (unless you know what you are doing) +; +; This subdirectory is a git "subrepo", and this file is maintained by the +; git-subrepo command. See https://github.com/git-commands/git-subrepo#readme +; +[subrepo] + remote = https://github.com/HarbourMasters/OTRExporter.git + branch = master + commit = 1503d3eefa0b51164371c60c2aae8ad057678319 + parent = d24c8453db1035f382e1b0853be00ebd281bbbdd + method = rebase + cmdver = 0.4.1 diff --git a/OTRExporter/CFG/ActorList_OoTMqDbg.txt b/OTRExporter/CFG/ActorList_OoTMqDbg.txt new file mode 100644 index 000000000..a0395eb27 --- /dev/null +++ b/OTRExporter/CFG/ActorList_OoTMqDbg.txt @@ -0,0 +1,472 @@ +ACTOR_PLAYER +ACTOR_UNSET_1 +ACTOR_EN_TEST +ACTOR_UNSET_3 +ACTOR_EN_GIRLA +ACTOR_UNSET_5 +ACTOR_UNSET_6 +ACTOR_EN_PART +ACTOR_EN_LIGHT +ACTOR_EN_DOOR +ACTOR_EN_BOX +ACTOR_BG_DY_YOSEIZO +ACTOR_BG_HIDAN_FIREWALL +ACTOR_EN_POH +ACTOR_EN_OKUTA +ACTOR_BG_YDAN_SP +ACTOR_EN_BOM +ACTOR_EN_WALLMAS +ACTOR_EN_DODONGO +ACTOR_EN_FIREFLY +ACTOR_EN_HORSE +ACTOR_EN_ITEM00 +ACTOR_EN_ARROW +ACTOR_UNSET_17 +ACTOR_EN_ELF +ACTOR_EN_NIW +ACTOR_UNSET_1A +ACTOR_EN_TITE +ACTOR_EN_REEBA +ACTOR_EN_PEEHAT +ACTOR_EN_BUTTE +ACTOR_UNSET_1F +ACTOR_EN_INSECT +ACTOR_EN_FISH +ACTOR_UNSET_22 +ACTOR_EN_HOLL +ACTOR_EN_SCENE_CHANGE +ACTOR_EN_ZF +ACTOR_EN_HATA +ACTOR_BOSS_DODONGO +ACTOR_BOSS_GOMA +ACTOR_EN_ZL1 +ACTOR_EN_VIEWER +ACTOR_EN_GOMA +ACTOR_BG_PUSHBOX +ACTOR_EN_BUBBLE +ACTOR_DOOR_SHUTTER +ACTOR_EN_DODOJR +ACTOR_EN_BDFIRE +ACTOR_UNSET_31 +ACTOR_EN_BOOM +ACTOR_EN_TORCH2 +ACTOR_EN_BILI +ACTOR_EN_TP +ACTOR_UNSET_36 +ACTOR_EN_ST +ACTOR_EN_BW +ACTOR_EN_A_OBJ +ACTOR_EN_EIYER +ACTOR_EN_RIVER_SOUND +ACTOR_EN_HORSE_NORMAL +ACTOR_EN_OSSAN +ACTOR_BG_TREEMOUTH +ACTOR_BG_DODOAGO +ACTOR_BG_HIDAN_DALM +ACTOR_BG_HIDAN_HROCK +ACTOR_EN_HORSE_GANON +ACTOR_BG_HIDAN_ROCK +ACTOR_BG_HIDAN_RSEKIZOU +ACTOR_BG_HIDAN_SEKIZOU +ACTOR_BG_HIDAN_SIMA +ACTOR_BG_HIDAN_SYOKU +ACTOR_EN_XC +ACTOR_BG_HIDAN_CURTAIN +ACTOR_BG_SPOT00_HANEBASI +ACTOR_EN_MB +ACTOR_EN_BOMBF +ACTOR_EN_ZL2 +ACTOR_BG_HIDAN_FSLIFT +ACTOR_EN_OE2 +ACTOR_BG_YDAN_HASI +ACTOR_BG_YDAN_MARUTA +ACTOR_BOSS_GANONDROF +ACTOR_UNSET_53 +ACTOR_EN_AM +ACTOR_EN_DEKUBABA +ACTOR_EN_M_FIRE1 +ACTOR_EN_M_THUNDER +ACTOR_BG_DDAN_JD +ACTOR_BG_BREAKWALL +ACTOR_EN_JJ +ACTOR_EN_HORSE_ZELDA +ACTOR_BG_DDAN_KD +ACTOR_DOOR_WARP1 +ACTOR_OBJ_SYOKUDAI +ACTOR_ITEM_B_HEART +ACTOR_EN_DEKUNUTS +ACTOR_BG_MENKURI_KAITEN +ACTOR_BG_MENKURI_EYE +ACTOR_EN_VALI +ACTOR_BG_MIZU_MOVEBG +ACTOR_BG_MIZU_WATER +ACTOR_ARMS_HOOK +ACTOR_EN_FHG +ACTOR_BG_MORI_HINERI +ACTOR_EN_BB +ACTOR_BG_TOKI_HIKARI +ACTOR_EN_YUKABYUN +ACTOR_BG_TOKI_SWD +ACTOR_EN_FHG_FIRE +ACTOR_BG_MJIN +ACTOR_BG_HIDAN_KOUSI +ACTOR_DOOR_TOKI +ACTOR_BG_HIDAN_HAMSTEP +ACTOR_EN_BIRD +ACTOR_UNSET_73 +ACTOR_UNSET_74 +ACTOR_UNSET_75 +ACTOR_UNSET_76 +ACTOR_EN_WOOD02 +ACTOR_UNSET_78 +ACTOR_UNSET_79 +ACTOR_UNSET_7A +ACTOR_UNSET_7B +ACTOR_EN_LIGHTBOX +ACTOR_EN_PU_BOX +ACTOR_UNSET_7E +ACTOR_UNSET_7F +ACTOR_EN_TRAP +ACTOR_EN_AROW_TRAP +ACTOR_EN_VASE +ACTOR_UNSET_83 +ACTOR_EN_TA +ACTOR_EN_TK +ACTOR_BG_MORI_BIGST +ACTOR_BG_MORI_ELEVATOR +ACTOR_BG_MORI_KAITENKABE +ACTOR_BG_MORI_RAKKATENJO +ACTOR_EN_VM +ACTOR_DEMO_EFFECT +ACTOR_DEMO_KANKYO +ACTOR_BG_HIDAN_FWBIG +ACTOR_EN_FLOORMAS +ACTOR_EN_HEISHI1 +ACTOR_EN_RD +ACTOR_EN_PO_SISTERS +ACTOR_BG_HEAVY_BLOCK +ACTOR_BG_PO_EVENT +ACTOR_OBJ_MURE +ACTOR_EN_SW +ACTOR_BOSS_FD +ACTOR_OBJECT_KANKYO +ACTOR_EN_DU +ACTOR_EN_FD +ACTOR_EN_HORSE_LINK_CHILD +ACTOR_DOOR_ANA +ACTOR_BG_SPOT02_OBJECTS +ACTOR_BG_HAKA +ACTOR_MAGIC_WIND +ACTOR_MAGIC_FIRE +ACTOR_UNSET_A0 +ACTOR_EN_RU1 +ACTOR_BOSS_FD2 +ACTOR_EN_FD_FIRE +ACTOR_EN_DH +ACTOR_EN_DHA +ACTOR_EN_RL +ACTOR_EN_ENCOUNT1 +ACTOR_DEMO_DU +ACTOR_DEMO_IM +ACTOR_DEMO_TRE_LGT +ACTOR_EN_FW +ACTOR_BG_VB_SIMA +ACTOR_EN_VB_BALL +ACTOR_BG_HAKA_MEGANE +ACTOR_BG_HAKA_MEGANEBG +ACTOR_BG_HAKA_SHIP +ACTOR_BG_HAKA_SGAMI +ACTOR_UNSET_B2 +ACTOR_EN_HEISHI2 +ACTOR_EN_ENCOUNT2 +ACTOR_EN_FIRE_ROCK +ACTOR_EN_BROB +ACTOR_MIR_RAY +ACTOR_BG_SPOT09_OBJ +ACTOR_BG_SPOT18_OBJ +ACTOR_BOSS_VA +ACTOR_BG_HAKA_TUBO +ACTOR_BG_HAKA_TRAP +ACTOR_BG_HAKA_HUTA +ACTOR_BG_HAKA_ZOU +ACTOR_BG_SPOT17_FUNEN +ACTOR_EN_SYATEKI_ITM +ACTOR_EN_SYATEKI_MAN +ACTOR_EN_TANA +ACTOR_EN_NB +ACTOR_BOSS_MO +ACTOR_EN_SB +ACTOR_EN_BIGOKUTA +ACTOR_EN_KAREBABA +ACTOR_BG_BDAN_OBJECTS +ACTOR_DEMO_SA +ACTOR_DEMO_GO +ACTOR_EN_IN +ACTOR_EN_TR +ACTOR_BG_SPOT16_BOMBSTONE +ACTOR_UNSET_CE +ACTOR_BG_HIDAN_KOWARERUKABE +ACTOR_BG_BOMBWALL +ACTOR_BG_SPOT08_ICEBLOCK +ACTOR_EN_RU2 +ACTOR_OBJ_DEKUJR +ACTOR_BG_MIZU_UZU +ACTOR_BG_SPOT06_OBJECTS +ACTOR_BG_ICE_OBJECTS +ACTOR_BG_HAKA_WATER +ACTOR_UNSET_D8 +ACTOR_EN_MA2 +ACTOR_EN_BOM_CHU +ACTOR_EN_HORSE_GAME_CHECK +ACTOR_BOSS_TW +ACTOR_EN_RR +ACTOR_EN_BA +ACTOR_EN_BX +ACTOR_EN_ANUBICE +ACTOR_EN_ANUBICE_FIRE +ACTOR_BG_MORI_HASHIGO +ACTOR_BG_MORI_HASHIRA4 +ACTOR_BG_MORI_IDOMIZU +ACTOR_BG_SPOT16_DOUGHNUT +ACTOR_BG_BDAN_SWITCH +ACTOR_EN_MA1 +ACTOR_BOSS_GANON +ACTOR_BOSS_SST +ACTOR_UNSET_EA +ACTOR_UNSET_EB +ACTOR_EN_NY +ACTOR_EN_FR +ACTOR_ITEM_SHIELD +ACTOR_BG_ICE_SHELTER +ACTOR_EN_ICE_HONO +ACTOR_ITEM_OCARINA +ACTOR_UNSET_F2 +ACTOR_UNSET_F3 +ACTOR_MAGIC_DARK +ACTOR_DEMO_6K +ACTOR_EN_ANUBICE_TAG +ACTOR_BG_HAKA_GATE +ACTOR_BG_SPOT15_SAKU +ACTOR_BG_JYA_GOROIWA +ACTOR_BG_JYA_ZURERUKABE +ACTOR_UNSET_FB +ACTOR_BG_JYA_COBRA +ACTOR_BG_JYA_KANAAMI +ACTOR_FISHING +ACTOR_OBJ_OSHIHIKI +ACTOR_BG_GATE_SHUTTER +ACTOR_EFF_DUST +ACTOR_BG_SPOT01_FUSYA +ACTOR_BG_SPOT01_IDOHASHIRA +ACTOR_BG_SPOT01_IDOMIZU +ACTOR_BG_PO_SYOKUDAI +ACTOR_BG_GANON_OTYUKA +ACTOR_BG_SPOT15_RRBOX +ACTOR_BG_UMAJUMP +ACTOR_UNSET_109 +ACTOR_ARROW_FIRE +ACTOR_ARROW_ICE +ACTOR_ARROW_LIGHT +ACTOR_UNSET_10D +ACTOR_UNSET_10E +ACTOR_ITEM_ETCETERA +ACTOR_OBJ_KIBAKO +ACTOR_OBJ_TSUBO +ACTOR_EN_WONDER_ITEM +ACTOR_EN_IK +ACTOR_DEMO_IK +ACTOR_EN_SKJ +ACTOR_EN_SKJNEEDLE +ACTOR_EN_G_SWITCH +ACTOR_DEMO_EXT +ACTOR_DEMO_SHD +ACTOR_EN_DNS +ACTOR_ELF_MSG +ACTOR_EN_HONOTRAP +ACTOR_EN_TUBO_TRAP +ACTOR_OBJ_ICE_POLY +ACTOR_BG_SPOT03_TAKI +ACTOR_BG_SPOT07_TAKI +ACTOR_EN_FZ +ACTOR_EN_PO_RELAY +ACTOR_BG_RELAY_OBJECTS +ACTOR_EN_DIVING_GAME +ACTOR_EN_KUSA +ACTOR_OBJ_BEAN +ACTOR_OBJ_BOMBIWA +ACTOR_UNSET_128 +ACTOR_UNSET_129 +ACTOR_OBJ_SWITCH +ACTOR_OBJ_ELEVATOR +ACTOR_OBJ_LIFT +ACTOR_OBJ_HSBLOCK +ACTOR_EN_OKARINA_TAG +ACTOR_EN_YABUSAME_MARK +ACTOR_EN_GOROIWA +ACTOR_EN_EX_RUPPY +ACTOR_EN_TORYO +ACTOR_EN_DAIKU +ACTOR_UNSET_134 +ACTOR_EN_NWC +ACTOR_EN_BLKOBJ +ACTOR_ITEM_INBOX +ACTOR_EN_GE1 +ACTOR_OBJ_BLOCKSTOP +ACTOR_EN_SDA +ACTOR_EN_CLEAR_TAG +ACTOR_EN_NIW_LADY +ACTOR_EN_GM +ACTOR_EN_MS +ACTOR_EN_HS +ACTOR_BG_INGATE +ACTOR_EN_KANBAN +ACTOR_EN_HEISHI3 +ACTOR_EN_SYATEKI_NIW +ACTOR_EN_ATTACK_NIW +ACTOR_BG_SPOT01_IDOSOKO +ACTOR_EN_SA +ACTOR_EN_WONDER_TALK +ACTOR_BG_GJYO_BRIDGE +ACTOR_EN_DS +ACTOR_EN_MK +ACTOR_EN_BOM_BOWL_MAN +ACTOR_EN_BOM_BOWL_PIT +ACTOR_EN_OWL +ACTOR_EN_ISHI +ACTOR_OBJ_HANA +ACTOR_OBJ_LIGHTSWITCH +ACTOR_OBJ_MURE2 +ACTOR_EN_GO +ACTOR_EN_FU +ACTOR_UNSET_154 +ACTOR_EN_CHANGER +ACTOR_BG_JYA_MEGAMI +ACTOR_BG_JYA_LIFT +ACTOR_BG_JYA_BIGMIRROR +ACTOR_BG_JYA_BOMBCHUIWA +ACTOR_BG_JYA_AMISHUTTER +ACTOR_BG_JYA_BOMBIWA +ACTOR_BG_SPOT18_BASKET +ACTOR_UNSET_15D +ACTOR_EN_GANON_ORGAN +ACTOR_EN_SIOFUKI +ACTOR_EN_STREAM +ACTOR_UNSET_161 +ACTOR_EN_MM +ACTOR_EN_KO +ACTOR_EN_KZ +ACTOR_EN_WEATHER_TAG +ACTOR_BG_SST_FLOOR +ACTOR_EN_ANI +ACTOR_EN_EX_ITEM +ACTOR_BG_JYA_IRONOBJ +ACTOR_EN_JS +ACTOR_EN_JSJUTAN +ACTOR_EN_CS +ACTOR_EN_MD +ACTOR_EN_HY +ACTOR_EN_GANON_MANT +ACTOR_EN_OKARINA_EFFECT +ACTOR_EN_MAG +ACTOR_DOOR_GERUDO +ACTOR_ELF_MSG2 +ACTOR_DEMO_GT +ACTOR_EN_PO_FIELD +ACTOR_EFC_ERUPC +ACTOR_BG_ZG +ACTOR_EN_HEISHI4 +ACTOR_EN_ZL3 +ACTOR_BOSS_GANON2 +ACTOR_EN_KAKASI +ACTOR_EN_TAKARA_MAN +ACTOR_OBJ_MAKEOSHIHIKI +ACTOR_OCEFF_SPOT +ACTOR_END_TITLE +ACTOR_UNSET_180 +ACTOR_EN_TORCH +ACTOR_DEMO_EC +ACTOR_SHOT_SUN +ACTOR_EN_DY_EXTRA +ACTOR_EN_WONDER_TALK2 +ACTOR_EN_GE2 +ACTOR_OBJ_ROOMTIMER +ACTOR_EN_SSH +ACTOR_EN_STH +ACTOR_OCEFF_WIPE +ACTOR_OCEFF_STORM +ACTOR_EN_WEIYER +ACTOR_BG_SPOT05_SOKO +ACTOR_BG_JYA_1FLIFT +ACTOR_BG_JYA_HAHENIRON +ACTOR_BG_SPOT12_GATE +ACTOR_BG_SPOT12_SAKU +ACTOR_EN_HINTNUTS +ACTOR_EN_NUTSBALL +ACTOR_BG_SPOT00_BREAK +ACTOR_EN_SHOPNUTS +ACTOR_EN_IT +ACTOR_EN_GELDB +ACTOR_OCEFF_WIPE2 +ACTOR_OCEFF_WIPE3 +ACTOR_EN_NIW_GIRL +ACTOR_EN_DOG +ACTOR_EN_SI +ACTOR_BG_SPOT01_OBJECTS2 +ACTOR_OBJ_COMB +ACTOR_BG_SPOT11_BAKUDANKABE +ACTOR_OBJ_KIBAKO2 +ACTOR_EN_DNT_DEMO +ACTOR_EN_DNT_JIJI +ACTOR_EN_DNT_NOMAL +ACTOR_EN_GUEST +ACTOR_BG_BOM_GUARD +ACTOR_EN_HS2 +ACTOR_DEMO_KEKKAI +ACTOR_BG_SPOT08_BAKUDANKABE +ACTOR_BG_SPOT17_BAKUDANKABE +ACTOR_UNSET_1AA +ACTOR_OBJ_MURE3 +ACTOR_EN_TG +ACTOR_EN_MU +ACTOR_EN_GO2 +ACTOR_EN_WF +ACTOR_EN_SKB +ACTOR_DEMO_GJ +ACTOR_DEMO_GEFF +ACTOR_BG_GND_FIREMEIRO +ACTOR_BG_GND_DARKMEIRO +ACTOR_BG_GND_SOULMEIRO +ACTOR_BG_GND_NISEKABE +ACTOR_BG_GND_ICEBLOCK +ACTOR_EN_GB +ACTOR_EN_GS +ACTOR_BG_MIZU_BWALL +ACTOR_BG_MIZU_SHUTTER +ACTOR_EN_DAIKU_KAKARIKO +ACTOR_BG_BOWL_WALL +ACTOR_EN_WALL_TUBO +ACTOR_EN_PO_DESERT +ACTOR_EN_CROW +ACTOR_DOOR_KILLER +ACTOR_BG_SPOT11_OASIS +ACTOR_BG_SPOT18_FUTA +ACTOR_BG_SPOT18_SHUTTER +ACTOR_EN_MA3 +ACTOR_EN_COW +ACTOR_BG_ICE_TURARA +ACTOR_BG_ICE_SHUTTER +ACTOR_EN_KAKASI2 +ACTOR_EN_KAKASI3 +ACTOR_OCEFF_WIPE4 +ACTOR_EN_EG +ACTOR_BG_MENKURI_NISEKABE +ACTOR_EN_ZO +ACTOR_OBJ_MAKEKINSUTA +ACTOR_EN_GE3 +ACTOR_OBJ_TIMEBLOCK +ACTOR_OBJ_HAMISHI +ACTOR_EN_ZL4 +ACTOR_EN_MM2 +ACTOR_BG_JYA_BLOCK +ACTOR_OBJ_WARP2BLOCK +ACTOR_ID_MAX \ No newline at end of file diff --git a/OTRExporter/CFG/Config.xml b/OTRExporter/CFG/Config.xml new file mode 100644 index 000000000..d9c3782e1 --- /dev/null +++ b/OTRExporter/CFG/Config.xml @@ -0,0 +1,8 @@ + + + + + + + + diff --git a/OTRExporter/CFG/ObjectList_OoTMqDbg.txt b/OTRExporter/CFG/ObjectList_OoTMqDbg.txt new file mode 100644 index 000000000..1ecc3441b --- /dev/null +++ b/OTRExporter/CFG/ObjectList_OoTMqDbg.txt @@ -0,0 +1,402 @@ +OBJECT_INVALID +OBJECT_GAMEPLAY_KEEP +OBJECT_GAMEPLAY_FIELD_KEEP +OBJECT_GAMEPLAY_DANGEON_KEEP +OBJECT_UNSET_4 +OBJECT_UNSET_5 +OBJECT_HUMAN +OBJECT_OKUTA +OBJECT_CROW +OBJECT_POH +OBJECT_DY_OBJ +OBJECT_WALLMASTER +OBJECT_DODONGO +OBJECT_FIREFLY +OBJECT_BOX +OBJECT_FIRE +OBJECT_UNSET_10 +OBJECT_UNSET_11 +OBJECT_BUBBLE +OBJECT_NIW +OBJECT_LINK_BOY +OBJECT_LINK_CHILD +OBJECT_TITE +OBJECT_REEBA +OBJECT_PEEHAT +OBJECT_KINGDODONGO +OBJECT_HORSE +OBJECT_ZF +OBJECT_GOMA +OBJECT_ZL1 +OBJECT_GOL +OBJECT_DODOJR +OBJECT_TORCH2 +OBJECT_BL +OBJECT_TP +OBJECT_OA1 +OBJECT_ST +OBJECT_BW +OBJECT_EI +OBJECT_HORSE_NORMAL +OBJECT_OB1 +OBJECT_O_ANIME +OBJECT_SPOT04_OBJECTS +OBJECT_DDAN_OBJECTS +OBJECT_HIDAN_OBJECTS +OBJECT_HORSE_GANON +OBJECT_OA2 +OBJECT_SPOT00_OBJECTS +OBJECT_MB +OBJECT_BOMBF +OBJECT_SK2 +OBJECT_OE1 +OBJECT_OE_ANIME +OBJECT_OE2 +OBJECT_YDAN_OBJECTS +OBJECT_GND +OBJECT_AM +OBJECT_DEKUBABA +OBJECT_UNSET_3A +OBJECT_OA3 +OBJECT_OA4 +OBJECT_OA5 +OBJECT_OA6 +OBJECT_OA7 +OBJECT_JJ +OBJECT_OA8 +OBJECT_OA9 +OBJECT_OB2 +OBJECT_OB3 +OBJECT_OB4 +OBJECT_HORSE_ZELDA +OBJECT_OPENING_DEMO1 +OBJECT_WARP1 +OBJECT_B_HEART +OBJECT_DEKUNUTS +OBJECT_OE3 +OBJECT_OE4 +OBJECT_MENKURI_OBJECTS +OBJECT_OE5 +OBJECT_OE6 +OBJECT_OE7 +OBJECT_OE8 +OBJECT_OE9 +OBJECT_OE10 +OBJECT_OE11 +OBJECT_OE12 +OBJECT_VALI +OBJECT_OA10 +OBJECT_OA11 +OBJECT_MIZU_OBJECTS +OBJECT_FHG +OBJECT_OSSAN +OBJECT_MORI_HINERI1 +OBJECT_BB +OBJECT_TOKI_OBJECTS +OBJECT_YUKABYUN +OBJECT_ZL2 +OBJECT_MJIN +OBJECT_MJIN_FLASH +OBJECT_MJIN_DARK +OBJECT_MJIN_FLAME +OBJECT_MJIN_ICE +OBJECT_MJIN_SOUL +OBJECT_MJIN_WIND +OBJECT_MJIN_OKA +OBJECT_HAKA_OBJECTS +OBJECT_SPOT06_OBJECTS +OBJECT_ICE_OBJECTS +OBJECT_RELAY_OBJECTS +OBJECT_PO_FIELD +OBJECT_PO_COMPOSER +OBJECT_MORI_HINERI1A +OBJECT_MORI_HINERI2 +OBJECT_MORI_HINERI2A +OBJECT_MORI_OBJECTS +OBJECT_MORI_TEX +OBJECT_SPOT08_OBJ +OBJECT_WARP2 +OBJECT_HATA +OBJECT_BIRD +OBJECT_UNSET_78 +OBJECT_UNSET_79 +OBJECT_UNSET_7A +OBJECT_UNSET_7B +OBJECT_WOOD02 +OBJECT_UNSET_7D +OBJECT_UNSET_7E +OBJECT_UNSET_7F +OBJECT_UNSET_80 +OBJECT_LIGHTBOX +OBJECT_PU_BOX +OBJECT_UNSET_83 +OBJECT_UNSET_84 +OBJECT_TRAP +OBJECT_VASE +OBJECT_IM +OBJECT_TA +OBJECT_TK +OBJECT_XC +OBJECT_VM +OBJECT_BV +OBJECT_HAKACH_OBJECTS +OBJECT_EFC_CRYSTAL_LIGHT +OBJECT_EFC_FIRE_BALL +OBJECT_EFC_FLASH +OBJECT_EFC_LGT_SHOWER +OBJECT_EFC_STAR_FIELD +OBJECT_GOD_LGT +OBJECT_LIGHT_RING +OBJECT_TRIFORCE_SPOT +OBJECT_BDAN_OBJECTS +OBJECT_SD +OBJECT_RD +OBJECT_PO_SISTERS +OBJECT_HEAVY_OBJECT +OBJECT_GNDD +OBJECT_FD +OBJECT_DU +OBJECT_FW +OBJECT_MEDAL +OBJECT_HORSE_LINK_CHILD +OBJECT_SPOT02_OBJECTS +OBJECT_HAKA +OBJECT_RU1 +OBJECT_SYOKUDAI +OBJECT_FD2 +OBJECT_DH +OBJECT_RL +OBJECT_EFC_TW +OBJECT_DEMO_TRE_LGT +OBJECT_GI_KEY +OBJECT_MIR_RAY +OBJECT_BROB +OBJECT_GI_JEWEL +OBJECT_SPOT09_OBJ +OBJECT_SPOT18_OBJ +OBJECT_BDOOR +OBJECT_SPOT17_OBJ +OBJECT_SHOP_DUNGEN +OBJECT_NB +OBJECT_MO +OBJECT_SB +OBJECT_GI_MELODY +OBJECT_GI_HEART +OBJECT_GI_COMPASS +OBJECT_GI_BOSSKEY +OBJECT_GI_MEDAL +OBJECT_GI_NUTS +OBJECT_SA +OBJECT_GI_HEARTS +OBJECT_GI_ARROWCASE +OBJECT_GI_BOMBPOUCH +OBJECT_IN +OBJECT_TR +OBJECT_SPOT16_OBJ +OBJECT_OE1S +OBJECT_OE4S +OBJECT_OS_ANIME +OBJECT_GI_BOTTLE +OBJECT_GI_STICK +OBJECT_GI_MAP +OBJECT_OF1D_MAP +OBJECT_RU2 +OBJECT_GI_SHIELD_1 +OBJECT_DEKUJR +OBJECT_GI_MAGICPOT +OBJECT_GI_BOMB_1 +OBJECT_OF1S +OBJECT_MA2 +OBJECT_GI_PURSE +OBJECT_HNI +OBJECT_TW +OBJECT_RR +OBJECT_BXA +OBJECT_ANUBICE +OBJECT_GI_GERUDO +OBJECT_GI_ARROW +OBJECT_GI_BOMB_2 +OBJECT_GI_EGG +OBJECT_GI_SCALE +OBJECT_GI_SHIELD_2 +OBJECT_GI_HOOKSHOT +OBJECT_GI_OCARINA +OBJECT_GI_MILK +OBJECT_MA1 +OBJECT_GANON +OBJECT_SST +OBJECT_NY_UNUSED +OBJECT_UNSET_E4 +OBJECT_NY +OBJECT_FR +OBJECT_GI_PACHINKO +OBJECT_GI_BOOMERANG +OBJECT_GI_BOW +OBJECT_GI_GLASSES +OBJECT_GI_LIQUID +OBJECT_ANI +OBJECT_DEMO_6K +OBJECT_GI_SHIELD_3 +OBJECT_GI_LETTER +OBJECT_SPOT15_OBJ +OBJECT_JYA_OBJ +OBJECT_GI_CLOTHES +OBJECT_GI_BEAN +OBJECT_GI_FISH +OBJECT_GI_SAW +OBJECT_GI_HAMMER +OBJECT_GI_GRASS +OBJECT_GI_LONGSWORD +OBJECT_SPOT01_OBJECTS +OBJECT_MD_UNUSED +OBJECT_MD +OBJECT_KM1 +OBJECT_KW1 +OBJECT_ZO +OBJECT_KZ +OBJECT_UMAJUMP +OBJECT_MASTERKOKIRI +OBJECT_MASTERKOKIRIHEAD +OBJECT_MASTERGOLON +OBJECT_MASTERZOORA +OBJECT_AOB +OBJECT_IK +OBJECT_AHG +OBJECT_CNE +OBJECT_GI_NIWATORI +OBJECT_SKJ +OBJECT_GI_BOTTLE_LETTER +OBJECT_BJI +OBJECT_BBA +OBJECT_GI_OCARINA_0 +OBJECT_DS +OBJECT_ANE +OBJECT_BOJ +OBJECT_SPOT03_OBJECT +OBJECT_SPOT07_OBJECT +OBJECT_FZ +OBJECT_BOB +OBJECT_GE1 +OBJECT_YABUSAME_POINT +OBJECT_GI_BOOTS_2 +OBJECT_GI_SEED +OBJECT_GND_MAGIC +OBJECT_D_ELEVATOR +OBJECT_D_HSBLOCK +OBJECT_D_LIFT +OBJECT_MAMENOKI +OBJECT_GOROIWA +OBJECT_UNSET_120 +OBJECT_TORYO +OBJECT_DAIKU +OBJECT_UNSET_123 +OBJECT_NWC +OBJECT_BLKOBJ +OBJECT_GM +OBJECT_MS +OBJECT_HS +OBJECT_INGATE +OBJECT_LIGHTSWITCH +OBJECT_KUSA +OBJECT_TSUBO +OBJECT_GI_GLOVES +OBJECT_GI_COIN +OBJECT_KANBAN +OBJECT_GJYO_OBJECTS +OBJECT_OWL +OBJECT_MK +OBJECT_FU +OBJECT_GI_KI_TAN_MASK +OBJECT_GI_REDEAD_MASK +OBJECT_GI_SKJ_MASK +OBJECT_GI_RABIT_MASK +OBJECT_GI_TRUTH_MASK +OBJECT_GANON_OBJECTS +OBJECT_SIOFUKI +OBJECT_STREAM +OBJECT_MM +OBJECT_FA +OBJECT_OS +OBJECT_GI_EYE_LOTION +OBJECT_GI_POWDER +OBJECT_GI_MUSHROOM +OBJECT_GI_TICKETSTONE +OBJECT_GI_BROKENSWORD +OBJECT_JS +OBJECT_CS +OBJECT_GI_PRESCRIPTION +OBJECT_GI_BRACELET +OBJECT_GI_SOLDOUT +OBJECT_GI_FROG +OBJECT_MAG +OBJECT_DOOR_GERUDO +OBJECT_GT +OBJECT_EFC_ERUPC +OBJECT_ZL2_ANIME1 +OBJECT_ZL2_ANIME2 +OBJECT_GI_GOLONMASK +OBJECT_GI_ZORAMASK +OBJECT_GI_GERUDOMASK +OBJECT_GANON2 +OBJECT_KA +OBJECT_TS +OBJECT_ZG +OBJECT_GI_HOVERBOOTS +OBJECT_GI_M_ARROW +OBJECT_DS2 +OBJECT_EC +OBJECT_FISH +OBJECT_GI_SUTARU +OBJECT_GI_GODDESS +OBJECT_SSH +OBJECT_BIGOKUTA +OBJECT_BG +OBJECT_SPOT05_OBJECTS +OBJECT_SPOT12_OBJ +OBJECT_BOMBIWA +OBJECT_HINTNUTS +OBJECT_RS +OBJECT_SPOT00_BREAK +OBJECT_GLA +OBJECT_SHOPNUTS +OBJECT_GELDB +OBJECT_GR +OBJECT_DOG +OBJECT_JYA_IRON +OBJECT_JYA_DOOR +OBJECT_UNSET_16E +OBJECT_SPOT11_OBJ +OBJECT_KIBAKO2 +OBJECT_DNS +OBJECT_DNK +OBJECT_GI_FIRE +OBJECT_GI_INSECT +OBJECT_GI_BUTTERFLY +OBJECT_GI_GHOST +OBJECT_GI_SOUL +OBJECT_BOWL +OBJECT_DEMO_KEKKAI +OBJECT_EFC_DOUGHNUT +OBJECT_GI_DEKUPOUCH +OBJECT_GANON_ANIME1 +OBJECT_GANON_ANIME2 +OBJECT_GANON_ANIME3 +OBJECT_GI_RUPY +OBJECT_SPOT01_MATOYA +OBJECT_SPOT01_MATOYAB +OBJECT_MU +OBJECT_WF +OBJECT_SKB +OBJECT_GJ +OBJECT_GEFF +OBJECT_HAKA_DOOR +OBJECT_GS +OBJECT_PS +OBJECT_BWALL +OBJECT_COW +OBJECT_COB +OBJECT_GI_SWORD_1 +OBJECT_DOOR_KILLER +OBJECT_OUKE_HAKA +OBJECT_TIMEBLOCK +OBJECT_ZL4 \ No newline at end of file diff --git a/OTRExporter/CFG/SymbolMap_OoTMqDbg.txt b/OTRExporter/CFG/SymbolMap_OoTMqDbg.txt new file mode 100644 index 000000000..015e7e88a --- /dev/null +++ b/OTRExporter/CFG/SymbolMap_OoTMqDbg.txt @@ -0,0 +1 @@ +8012DB20 gMtxClear \ No newline at end of file diff --git a/OTRExporter/CFG/TexturePool.xml b/OTRExporter/CFG/TexturePool.xml new file mode 100644 index 000000000..924ded703 --- /dev/null +++ b/OTRExporter/CFG/TexturePool.xml @@ -0,0 +1,952 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/OTRExporter/LICENSE b/OTRExporter/LICENSE new file mode 100644 index 000000000..59ddd97bc --- /dev/null +++ b/OTRExporter/LICENSE @@ -0,0 +1,9 @@ +Copyright (c) 2022 Harbour Masters + +MIT License + +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. \ No newline at end of file diff --git a/OTRExporter/OTRExporter.sln b/OTRExporter/OTRExporter.sln new file mode 100644 index 000000000..496851f24 --- /dev/null +++ b/OTRExporter/OTRExporter.sln @@ -0,0 +1,68 @@ +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 diff --git a/OTRExporter/OTRExporter/AnimationExporter.cpp b/OTRExporter/OTRExporter/AnimationExporter.cpp new file mode 100644 index 000000000..4f031b8a8 --- /dev/null +++ b/OTRExporter/OTRExporter/AnimationExporter.cpp @@ -0,0 +1,70 @@ +#include "AnimationExporter.h" +#include + +void OTRExporter_Animation::Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer) +{ + ZAnimation* anim = (ZAnimation*)res; + + WriteHeader(res, outPath, writer, Ship::ResourceType::Animation); + + ZNormalAnimation* normalAnim = dynamic_cast(anim); + ZCurveAnimation* curveAnim = dynamic_cast(anim); + ZLinkAnimation* linkAnim = dynamic_cast(anim); + if (linkAnim != nullptr) + { + writer->Write((uint32_t)Ship::AnimationType::Link); + writer->Write((uint16_t)linkAnim->frameCount); + writer->Write((uint32_t)linkAnim->segmentAddress); + } + else if (curveAnim != nullptr) + { + writer->Write((uint32_t)Ship::AnimationType::Curve); + writer->Write((uint16_t)curveAnim->frameCount); + + writer->Write((uint32_t)curveAnim->refIndexArr.size()); + + for (auto val : curveAnim->refIndexArr) + writer->Write(val); + + writer->Write((uint32_t)curveAnim->transformDataArr.size()); + + for (auto val : curveAnim->transformDataArr) + { + writer->Write(val.unk_00); + writer->Write(val.unk_02); + writer->Write(val.unk_04); + writer->Write(val.unk_06); + writer->Write(val.unk_08); + } + + writer->Write((uint32_t)curveAnim->copyValuesArr.size()); + + for (auto val : curveAnim->copyValuesArr) + writer->Write(val); + } + else if (normalAnim != nullptr) + { + writer->Write((uint32_t)Ship::AnimationType::Normal); + writer->Write((uint16_t)normalAnim->frameCount); + + writer->Write((uint32_t)normalAnim->rotationValues.size()); + + for (int 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++) + { + writer->Write(normalAnim->rotationIndices[i].x); + writer->Write(normalAnim->rotationIndices[i].y); + writer->Write(normalAnim->rotationIndices[i].z); + } + + writer->Write(normalAnim->limit); + } + else + { + writer->Write((uint32_t)Ship::AnimationType::Legacy); + } +} diff --git a/OTRExporter/OTRExporter/AnimationExporter.h b/OTRExporter/OTRExporter/AnimationExporter.h new file mode 100644 index 000000000..58fddb2fd --- /dev/null +++ b/OTRExporter/OTRExporter/AnimationExporter.h @@ -0,0 +1,13 @@ +#pragma once + +#include "ZResource.h" +#include "ZTexture.h" +#include "ZAnimation.h" +#include "Exporter.h" +#include + +class OTRExporter_Animation : public OTRExporter +{ +public: + virtual void Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer) override; +}; \ No newline at end of file diff --git a/OTRExporter/OTRExporter/ArrayExporter.cpp b/OTRExporter/OTRExporter/ArrayExporter.cpp new file mode 100644 index 000000000..2ddfd7b10 --- /dev/null +++ b/OTRExporter/OTRExporter/ArrayExporter.cpp @@ -0,0 +1,104 @@ +#include "ArrayExporter.h" +#include "VtxExporter.h" +#include +void OTRExporter_Array::Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer) +{ + ZArray* arr = (ZArray*)res; + + WriteHeader(res, outPath, writer, Ship::ResourceType::Array); + + writer->Write((uint32_t)arr->resList[0]->GetResourceType()); + writer->Write((uint32_t)arr->arrayCnt); + + for (int i = 0; i < arr->arrayCnt; i++) + { + if (arr->resList[i]->GetResourceType() == ZResourceType::Vertex) + { + ZVtx* vtx = (ZVtx*)arr->resList[i]; + writer->Write(vtx->x); + writer->Write(vtx->y); + writer->Write(vtx->z); + writer->Write(vtx->flag); + writer->Write(vtx->s); + writer->Write(vtx->t); + writer->Write(vtx->r); + writer->Write(vtx->g); + writer->Write(vtx->b); + writer->Write(vtx->a); + } + else if (arr->resList[i]->GetResourceType() == ZResourceType::Vector) + { + ZVector* vec = (ZVector*)arr->resList[i]; + writer->Write((uint32_t)vec->scalarType); + writer->Write((uint32_t)vec->dimensions); + + for (int k = 0; k < vec->dimensions; k++) + { + // OTRTODO: Duplicate code here. Cleanup at a later date... + switch (vec->scalarType) + { + case ZScalarType::ZSCALAR_U8: + writer->Write(vec->scalars[k].scalarData.u8); + break; + case ZScalarType::ZSCALAR_S8: + writer->Write(vec->scalars[k].scalarData.s8); + break; + case ZScalarType::ZSCALAR_U16: + writer->Write(vec->scalars[k].scalarData.u16); + break; + case ZScalarType::ZSCALAR_S16: + writer->Write(vec->scalars[k].scalarData.s16); + break; + case ZScalarType::ZSCALAR_S32: + writer->Write(vec->scalars[k].scalarData.s32); + break; + case ZScalarType::ZSCALAR_U32: + writer->Write(vec->scalars[k].scalarData.u32); + break; + case ZScalarType::ZSCALAR_S64: + writer->Write(vec->scalars[k].scalarData.s64); + break; + case ZScalarType::ZSCALAR_U64: + writer->Write(vec->scalars[k].scalarData.u64); + break; + // OTRTODO: ADD OTHER TYPES + } + } + } + else + { + ZScalar* scal = (ZScalar*)arr->resList[i]; + + writer->Write((uint32_t)scal->scalarType); + + switch (scal->scalarType) + { + case ZScalarType::ZSCALAR_U8: + writer->Write(scal->scalarData.u8); + break; + case ZScalarType::ZSCALAR_S8: + writer->Write(scal->scalarData.s8); + break; + case ZScalarType::ZSCALAR_U16: + writer->Write(scal->scalarData.u16); + break; + case ZScalarType::ZSCALAR_S16: + writer->Write(scal->scalarData.s16); + break; + case ZScalarType::ZSCALAR_S32: + writer->Write(scal->scalarData.s32); + break; + case ZScalarType::ZSCALAR_U32: + writer->Write(scal->scalarData.u32); + break; + case ZScalarType::ZSCALAR_S64: + writer->Write(scal->scalarData.s64); + break; + case ZScalarType::ZSCALAR_U64: + writer->Write(scal->scalarData.u64); + break; + // OTRTODO: ADD OTHER TYPES + } + } + } +} \ No newline at end of file diff --git a/OTRExporter/OTRExporter/ArrayExporter.h b/OTRExporter/OTRExporter/ArrayExporter.h new file mode 100644 index 000000000..1d2dc0f2b --- /dev/null +++ b/OTRExporter/OTRExporter/ArrayExporter.h @@ -0,0 +1,12 @@ +#pragma once +#include "ZResource.h" +#include "ZArray.h" +#include "Exporter.h" +#include + +class OTRExporter_Array : public OTRExporter +{ +public: + virtual void Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer) override; + +}; \ No newline at end of file diff --git a/OTRExporter/OTRExporter/BackgroundExporter.cpp b/OTRExporter/OTRExporter/BackgroundExporter.cpp new file mode 100644 index 000000000..bf68255b7 --- /dev/null +++ b/OTRExporter/OTRExporter/BackgroundExporter.cpp @@ -0,0 +1,10 @@ +#include "BackgroundExporter.h" +#include "../ZAPD/ZFile.h" + +void OTRExporter_Background::Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer) +{ + ZBackground* bg = (ZBackground*)res; + + auto data = bg->parent->GetRawData(); + writer->Write((char*)data.data() + bg->GetRawDataIndex(), bg->GetRawDataSize()); +} \ No newline at end of file diff --git a/OTRExporter/OTRExporter/BackgroundExporter.h b/OTRExporter/OTRExporter/BackgroundExporter.h new file mode 100644 index 000000000..30c1adbbc --- /dev/null +++ b/OTRExporter/OTRExporter/BackgroundExporter.h @@ -0,0 +1,12 @@ +#pragma once + +#include "ZResource.h" +#include "ZBackground.h" +#include "Exporter.h" +#include + +class OTRExporter_Background : public OTRExporter +{ +public: + virtual void Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer) override; +}; \ No newline at end of file diff --git a/OTRExporter/OTRExporter/BlobExporter.cpp b/OTRExporter/OTRExporter/BlobExporter.cpp new file mode 100644 index 000000000..24cb9c1e0 --- /dev/null +++ b/OTRExporter/OTRExporter/BlobExporter.cpp @@ -0,0 +1,21 @@ +#include "BlobExporter.h" +#include "../ZAPD/ZFile.h" + +void OTRExporter_Blob::Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer) +{ + ZBlob* blob = (ZBlob*)res; + + WriteHeader(blob, outPath, writer, Ship::ResourceType::Blob); + + auto start = std::chrono::steady_clock::now(); + + writer->Write((uint32_t)blob->GetRawDataSize()); + + auto data = blob->parent->GetRawData(); + + for (size_t i = blob->GetRawDataIndex(); i < blob->GetRawDataIndex() + blob->GetRawDataSize(); i++) + writer->Write(data[i]); + + auto end = std::chrono::steady_clock::now(); + size_t diff = std::chrono::duration_cast(end - start).count(); +} \ No newline at end of file diff --git a/OTRExporter/OTRExporter/BlobExporter.h b/OTRExporter/OTRExporter/BlobExporter.h new file mode 100644 index 000000000..43a262d5e --- /dev/null +++ b/OTRExporter/OTRExporter/BlobExporter.h @@ -0,0 +1,12 @@ +#pragma once + +#include "ZResource.h" +#include "ZBlob.h" +#include "Exporter.h" +#include + +class OTRExporter_Blob : public OTRExporter +{ +public: + virtual void Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer) override; +}; \ No newline at end of file diff --git a/OTRExporter/OTRExporter/CollisionExporter.cpp b/OTRExporter/OTRExporter/CollisionExporter.cpp new file mode 100644 index 000000000..02f20e674 --- /dev/null +++ b/OTRExporter/OTRExporter/CollisionExporter.cpp @@ -0,0 +1,82 @@ +#include "CollisionExporter.h" +#include + +void OTRExporter_Collision::Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer) +{ + ZCollisionHeader* col = (ZCollisionHeader*)res; + + WriteHeader(res, outPath, writer, Ship::ResourceType::CollisionHeader); + + writer->Write(col->absMinX); + writer->Write(col->absMinY); + writer->Write(col->absMinZ); + + writer->Write(col->absMaxX); + writer->Write(col->absMaxY); + writer->Write(col->absMaxZ); + + writer->Write((uint32_t)col->vertices.size()); + + for (uint16_t i = 0; i < col->vertices.size(); i++) + { + writer->Write(col->vertices[i].scalars[0].scalarData.s16); + writer->Write(col->vertices[i].scalars[1].scalarData.s16); + writer->Write(col->vertices[i].scalars[2].scalarData.s16); + } + + writer->Write((uint32_t)col->polygons.size()); + + for (uint16_t i = 0; i < col->polygons.size(); i++) + { + writer->Write(col->polygons[i].type); + writer->Write(col->polygons[i].vtxA); + writer->Write(col->polygons[i].vtxB); + writer->Write(col->polygons[i].vtxC); + writer->Write(col->polygons[i].a); + writer->Write(col->polygons[i].b); + writer->Write(col->polygons[i].c); + writer->Write(col->polygons[i].d); + } + + writer->Write((uint32_t)col->polygonTypes.size()); + + for (uint16_t i = 0; i < col->polygonTypes.size(); i++) + writer->Write(col->polygonTypes[i]); + + writer->Write((uint32_t)col->camData->entries.size()); + + for (auto entry : col->camData->entries) + { + auto camPosDecl = col->parent->GetDeclarationRanged(Seg2Filespace(entry->cameraPosDataSeg, col->parent->baseAddress)); + + int idx = 0; + + if (camPosDecl != nullptr) + idx = ((entry->cameraPosDataSeg & 0x00FFFFFF) - camPosDecl->address) / 6; + + writer->Write(entry->cameraSType); + writer->Write(entry->numData); + writer->Write((uint32_t)idx); + } + + writer->Write((uint32_t)col->camData->cameraPositionData.size()); + + for (auto entry : col->camData->cameraPositionData) + { + writer->Write(entry->x); + writer->Write(entry->y); + writer->Write(entry->z); + } + + writer->Write((uint32_t)col->waterBoxes.size()); + + for (auto waterBox : col->waterBoxes) + { + writer->Write(waterBox.xMin); + writer->Write(waterBox.ySurface); + writer->Write(waterBox.zMin); + writer->Write(waterBox.xLength); + writer->Write(waterBox.zLength); + writer->Write(waterBox.properties); + } +} diff --git a/OTRExporter/OTRExporter/CollisionExporter.h b/OTRExporter/OTRExporter/CollisionExporter.h new file mode 100644 index 000000000..536d65344 --- /dev/null +++ b/OTRExporter/OTRExporter/CollisionExporter.h @@ -0,0 +1,11 @@ +#pragma once + +#include "ZResource.h" +#include "ZCollision.h" +#include "Exporter.h" + +class OTRExporter_Collision : public OTRExporter +{ +public: + virtual void Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer) override; +}; \ No newline at end of file diff --git a/OTRExporter/OTRExporter/CutsceneExporter.cpp b/OTRExporter/OTRExporter/CutsceneExporter.cpp new file mode 100644 index 000000000..7cbf7f175 --- /dev/null +++ b/OTRExporter/OTRExporter/CutsceneExporter.cpp @@ -0,0 +1,431 @@ +#include "CutsceneExporter.h" +#include + +void OTRExporter_Cutscene::Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer) +{ + ZCutscene* cs = (ZCutscene*)res; + + WriteHeader(cs, outPath, writer, Ship::ResourceType::Cutscene); + + //writer->Write((uint32_t)cs->commands.size() + 2 + 2); + writer->Write((uint32_t)0); + + int currentStream = writer->GetBaseAddress(); + + writer->Write(CS_BEGIN_CUTSCENE(cs->numCommands, cs->endFrame)); + + for (size_t i = 0; i < cs->commands.size(); i++) + { + switch (cs->commands[i]->commandID) + { + case (uint32_t)CutsceneCommands::SetCameraPos: + { + CutsceneCommandSetCameraPos* cmdCamPos = (CutsceneCommandSetCameraPos*)cs->commands[i]; + + writer->Write(CS_CMD_CAM_EYE); + writer->Write(CMD_HH(0x0001, ((CutsceneCommandSetCameraPos*)cs->commands[i])->startFrame)); + writer->Write(CMD_HH(cmdCamPos->endFrame, 0x0000)); + + 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(CMD_HH(e->posX, e->posY)); + writer->Write(CMD_HH(e->posZ, e->unused)); + } + } + break; + case (uint32_t)CutsceneCommands::SetCameraFocus: + { + CutsceneCommandSetCameraPos* cmdCamPos = (CutsceneCommandSetCameraPos*)cs->commands[i]; + + writer->Write(CS_CMD_CAM_AT); + writer->Write(CMD_HH(0x0001, cmdCamPos->startFrame)); + writer->Write(CMD_HH(cmdCamPos->endFrame, 0x0000)); + + 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(CMD_HH(e->posX, e->posY)); + writer->Write(CMD_HH(e->posZ, e->unused)); + } + break; + } + case (uint32_t)CutsceneCommands::SpecialAction: + { + writer->Write(CS_CMD_MISC); + writer->Write((uint32_t)CMD_W(((CutsceneCommandSpecialAction*)cs->commands[i])->entries.size())); + for (auto& e : ((CutsceneCommandSpecialAction*)cs->commands[i])->entries) //All in OOT seem to only have 1 entry + { + writer->Write(CMD_HH(e->base, e->startFrame)); + writer->Write(CMD_HH(e->endFrame, e->unused0)); + writer->Write(CMD_W(e->unused1)); + writer->Write(CMD_W(e->unused2)); + writer->Write(CMD_W(e->unused3)); + writer->Write(CMD_W(e->unused4)); + writer->Write(CMD_W(e->unused5)); + writer->Write(CMD_W(e->unused6)); + writer->Write(CMD_W(e->unused7)); + writer->Write(CMD_W(e->unused8)); + writer->Write(CMD_W(e->unused9)); + writer->Write(CMD_W(e->unused10)); + } + break; + } + case (uint32_t)CutsceneCommands::SetLighting: + { + writer->Write(CS_CMD_SET_LIGHTING); + writer->Write((uint32_t)CMD_W(((CutsceneCommandEnvLighting*)cs->commands[i])->entries.size())); + for (auto& e : ((CutsceneCommandEnvLighting*)cs->commands[i])->entries) + { + writer->Write(CMD_HH(e->setting, e->startFrame)); + writer->Write(CMD_HH(e->endFrame, e->unused0)); + writer->Write(CMD_W(e->unused1)); + writer->Write(CMD_W(e->unused2)); + writer->Write(CMD_W(e->unused3)); + writer->Write(CMD_W(e->unused4)); + writer->Write(CMD_W(e->unused5)); + writer->Write(CMD_W(e->unused6)); + writer->Write(CMD_W(e->unused7)); + writer->Write((uint32_t)0x0); + writer->Write((uint32_t)0x0); + writer->Write((uint32_t)0x0); + } + break; + } + case (uint32_t)CutsceneCommands::SetCameraPosLink: + { + CutsceneCommandSetCameraPos* cmdCamPos = (CutsceneCommandSetCameraPos*)cs->commands[i]; + + writer->Write(CS_CMD_CAM_EYE_REL_TO_PLAYER); + writer->Write(CMD_HH(0x0001, ((CutsceneCommandSetCameraPos*)cs->commands[i])->startFrame)); + writer->Write(CMD_HH(cmdCamPos->endFrame, 0x0000)); + + 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(CMD_HH(e->posX, e->posY)); + writer->Write(CMD_HH(e->posZ, e->unused)); + } + break; + } + case (uint32_t)CutsceneCommands::SetCameraFocusLink: + { + CutsceneCommandSetCameraPos* cmdCamPos = (CutsceneCommandSetCameraPos*)cs->commands[i]; + + writer->Write(CS_CMD_CAM_AT_REL_TO_PLAYER); + writer->Write(CMD_HH(0x0001, ((CutsceneCommandSetCameraPos*)cs->commands[i])->startFrame)); + writer->Write(CMD_HH(cmdCamPos->endFrame, 0x0000)); + + 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(CMD_HH(e->posX, e->posY)); + writer->Write(CMD_HH(e->posZ, e->unused)); + } + break; + } + + case (uint32_t)CutsceneCommands::Cmd07: // Not used in OOT + break; + case (uint32_t)CutsceneCommands::Cmd08: // Not used in OOT + break; + + case (uint32_t)CutsceneCommands::Cmd09: + { + writer->Write(CS_CMD_09); + writer->Write((uint32_t)CMD_W(((CutsceneCommandUnknown9*)cs->commands[i])->entries.size())); + + for (auto& e : ((CutsceneCommandUnknown9*)cs->commands[i])->entries) + { + writer->Write(CMD_HH(e->base, e->startFrame)); + writer->Write(CMD_HBB(e->endFrame, e->unk2, e->unk3)); + writer->Write(CMD_BBH(e->unk4, e->unused0, e->unused1)); + } + break; + } + case 0x15: + case (uint32_t)CutsceneCommands::Unknown: + { + CutsceneCommandUnknown* cmdUnk = (CutsceneCommandUnknown*)cs->commands[i]; + writer->Write((uint32_t)cs->commands[i]->commandID); + writer->Write((uint32_t)cmdUnk->entries.size()); + + for (auto e : cmdUnk->entries) + { + writer->Write(CMD_W(e->unused0)); + writer->Write(CMD_W(e->unused1)); + writer->Write(CMD_W(e->unused2)); + writer->Write(CMD_W(e->unused3)); + writer->Write(CMD_W(e->unused4)); + writer->Write(CMD_W(e->unused5)); + writer->Write(CMD_W(e->unused6)); + writer->Write(CMD_W(e->unused7)); + writer->Write(CMD_W(e->unused8)); + writer->Write(CMD_W(e->unused9)); + writer->Write(CMD_W(e->unused10)); + writer->Write(CMD_W(e->unused11)); + } + } + break; + case (uint32_t)CutsceneCommands::Textbox: + { + writer->Write(CS_CMD_TEXTBOX); + writer->Write((uint32_t)CMD_W(((CutsceneCommandTextbox*)cs->commands[i])->entries.size())); + + for (auto& e : ((CutsceneCommandTextbox*)cs->commands[i])->entries) + { + if (e->base == 0xFFFF) // CS_TEXT_NONE + { + writer->Write(CMD_HH(0xFFFF, e->startFrame)); + writer->Write(CMD_HH(e->endFrame, 0xFFFF)); + writer->Write(CMD_HH(0xFFFF, 0xFFFF)); + } + else // CS_TEXT_DISPLAY_TEXTBOX + { + writer->Write(CMD_HH(e->base, e->startFrame)); + writer->Write(CMD_HH(e->endFrame, e->type)); + writer->Write(CMD_HH(e->textID1, e->textID2)); + } + } + break; + } + case (uint32_t)CutsceneCommands::SetActorAction0: + case (uint32_t)CutsceneCommands::SetActorAction1: + case 17: + case 18: + case 23: + case 34: + case 39: + case 46: + case 76: + case 85: + case 93: + case 105: + case 107: + case 110: + case 119: + case 123: + case 138: + case 139: + case 144: + case (uint32_t)CutsceneCommands::SetActorAction2: + case 16: + case 24: + case 35: + case 40: + case 48: + case 64: + case 68: + case 70: + case 78: + case 80: + case 94: + case 116: + case 118: + case 120: + case 125: + case 131: + case 141: + case (uint32_t)CutsceneCommands::SetActorAction3: + case 36: + case 41: + case 50: + case 67: + case 69: + case 72: + case 74: + case 81: + case 106: + case 117: + case 121: + case 126: + case 132: + case (uint32_t)CutsceneCommands::SetActorAction4: + case 37: + case 42: + case 51: + case 53: + case 63: + case 65: + case 66: + case 75: + case 82: + case 108: + case 127: + case 133: + case (uint32_t)CutsceneCommands::SetActorAction5: + case 38: + case 43: + case 47: + case 54: + case 79: + case 83: + case 128: + case 135: + case (uint32_t)CutsceneCommands::SetActorAction6: + case 55: + case 77: + case 84: + case 90: + case 129: + case 136: + case (uint32_t)CutsceneCommands::SetActorAction7: + case 52: + case 57: + case 58: + case 88: + case 115: + case 130: + case 137: + case (uint32_t)CutsceneCommands::SetActorAction8: + case 60: + case 89: + case 111: + case 114: + case 134: + case 142: + case (uint32_t)CutsceneCommands::SetActorAction9: + case (uint32_t)CutsceneCommands::SetActorAction10: + { + writer->Write((uint32_t)(CutsceneCommands)cs->commands[i]->commandID); + writer->Write((uint32_t)CMD_W(((CutsceneCommandActorAction*)cs->commands[i])->entries.size())); + + for (auto& actorAct : ((CutsceneCommandActorAction*)cs->commands[i])->entries) + { + writer->Write(CMD_HH(actorAct->action, actorAct->startFrame)); + writer->Write(CMD_HH(actorAct->endFrame, actorAct->rotX)); + writer->Write(CMD_HH(actorAct->rotY, actorAct->rotZ)); + writer->Write(CMD_W(actorAct->startPosX)); + writer->Write(CMD_W(actorAct->startPosY)); + writer->Write(CMD_W(actorAct->startPosZ)); + writer->Write(CMD_W(actorAct->endPosX)); + writer->Write(CMD_W(actorAct->endPosY)); + writer->Write(CMD_W(actorAct->endPosZ)); + writer->Write(CMD_W(actorAct->normalX)); + writer->Write(CMD_W(actorAct->normalY)); + writer->Write(CMD_W(actorAct->normalZ)); + } + + break; + } + case (uint32_t)CutsceneCommands::SetSceneTransFX: + { + CutsceneCommandSceneTransFX* cmdTFX = (CutsceneCommandSceneTransFX*)cs->commands[i]; + + writer->Write(CS_CMD_SCENE_TRANS_FX); + writer->Write((uint32_t)1); + writer->Write(CMD_HH((((CutsceneCommandSceneTransFX*)cs->commands[i])->base), ((CutsceneCommandSceneTransFX*)cs->commands[i])->startFrame)); + writer->Write(CMD_HH((((CutsceneCommandSceneTransFX*)cs->commands[i])->endFrame), ((CutsceneCommandSceneTransFX*)cs->commands[i])->endFrame)); + break; + } + case (uint32_t)CutsceneCommands::Nop: //Not used in OOT + break; + case (uint32_t)CutsceneCommands::PlayBGM: + { + writer->Write(CS_CMD_PLAYBGM); + writer->Write((uint32_t)CMD_W(((CutsceneCommandPlayBGM*)cs->commands[i])->entries.size())); + + for (auto& e : ((CutsceneCommandPlayBGM*)cs->commands[i])->entries) + { + writer->Write(CMD_HH(e->sequence, e->startFrame)); + writer->Write(CMD_HH(e->endFrame, e->unknown0)); + writer->Write(CMD_W(e->unknown1)); + writer->Write(CMD_W(e->unknown2)); + writer->Write(CMD_W(e->unknown3)); + writer->Write(CMD_W(e->unknown4)); + writer->Write(CMD_W(e->unknown5)); + writer->Write(CMD_W(e->unknown6)); + writer->Write(CMD_W(e->unknown7)); + writer->Write((uint32_t)0); + writer->Write((uint32_t)0); + writer->Write((uint32_t)0); + } + break; + } + case (uint32_t)CutsceneCommands::StopBGM: + { + writer->Write(CS_CMD_STOPBGM); + writer->Write((uint32_t)CMD_W(((CutsceneCommandStopBGM*)cs->commands[i])->entries.size())); + + for (auto& e : ((CutsceneCommandStopBGM*)cs->commands[i])->entries) + { + writer->Write(CMD_HH(e->sequence, e->startFrame)); + writer->Write(CMD_HH(e->endFrame, e->unknown0)); + writer->Write(CMD_W(e->unknown1)); + writer->Write(CMD_W(e->unknown2)); + writer->Write(CMD_W(e->unknown3)); + writer->Write(CMD_W(e->unknown4)); + writer->Write(CMD_W(e->unknown5)); + writer->Write(CMD_W(e->unknown6)); + writer->Write(CMD_W(e->unknown7)); + writer->Write((uint32_t)0); + writer->Write((uint32_t)0); + writer->Write((uint32_t)0); + } + break; + } + case (uint32_t)CutsceneCommands::FadeBGM: + { + writer->Write(CS_CMD_FADEBGM); + writer->Write((uint32_t)CMD_W(((CutsceneCommandFadeBGM*)cs->commands[i])->entries.size())); + + for (auto& e : ((CutsceneCommandFadeBGM*)cs->commands[i])->entries) + { + writer->Write(CMD_HH(e->base, e->startFrame)); + writer->Write(CMD_HH(e->endFrame, e->unknown0)); + writer->Write(CMD_W(e->unknown1)); + writer->Write(CMD_W(e->unknown2)); + writer->Write(CMD_W(e->unknown3)); + writer->Write(CMD_W(e->unknown4)); + writer->Write(CMD_W(e->unknown5)); + writer->Write(CMD_W(e->unknown6)); + writer->Write(CMD_W(e->unknown7)); + writer->Write((uint32_t)0); + writer->Write((uint32_t)0); + writer->Write((uint32_t)0); + } + break; + } + case (uint32_t)CutsceneCommands::SetTime: + { + writer->Write(CS_CMD_SETTIME); + writer->Write((uint32_t)CMD_W(((CutsceneCommandDayTime*)cs->commands[i])->entries.size())); + + for (auto& e : ((CutsceneCommandDayTime*)cs->commands[i])->entries) + { + writer->Write(CMD_HH(e->base, e->startFrame)); + writer->Write(CMD_HBB(e->endFrame, e->hour, e->minute)); + writer->Write((uint32_t)CMD_W(e->unused)); + } + break; + } + case (uint32_t)CutsceneCommands::Terminator: + { + writer->Write(CS_CMD_TERMINATOR); + writer->Write((uint32_t)1); + writer->Write(CMD_HH(((CutsceneCommandTerminator*)cs->commands[i])->base, ((CutsceneCommandTerminator*)cs->commands[i])->startFrame)); + writer->Write(CMD_HH(((CutsceneCommandTerminator*)cs->commands[i])->endFrame, ((CutsceneCommandTerminator*)cs->commands[i])->endFrame)); + break; + } + default: + { + //writer->Write((uint32_t)cs->commands[i]->commandID); + printf("Undefined CS Opcode: %04X\n", cs->commands[i]->commandID); + } + break; + } + } + + //CS_END + writer->Write(0xFFFFFFFF); + writer->Write((uint32_t)0); + + int endStream = writer->GetBaseAddress(); + writer->Seek(currentStream - 4, SeekOffsetType::Start); + writer->Write((uint32_t)((endStream - currentStream) / 4)); + writer->Seek(endStream, SeekOffsetType::Start); +} \ No newline at end of file diff --git a/OTRExporter/OTRExporter/CutsceneExporter.h b/OTRExporter/OTRExporter/CutsceneExporter.h new file mode 100644 index 000000000..96903fdba --- /dev/null +++ b/OTRExporter/OTRExporter/CutsceneExporter.h @@ -0,0 +1,11 @@ +#pragma once +#include "ZResource.h" +#include "ZCutscene.h" +#include "z64cutscene_commands.h" +#include "Exporter.h" + +class OTRExporter_Cutscene : public OTRExporter +{ +public: + virtual void Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer) override; +}; \ No newline at end of file diff --git a/OTRExporter/OTRExporter/DisplayListExporter.cpp b/OTRExporter/OTRExporter/DisplayListExporter.cpp new file mode 100644 index 000000000..4d4f067b1 --- /dev/null +++ b/OTRExporter/OTRExporter/DisplayListExporter.cpp @@ -0,0 +1,973 @@ +#include "DisplayListExporter.h" +#include "Main.h" +#include "../ZAPD/ZFile.h" +#include +#include +#include "Lib/StrHash64.h" +#include "spdlog/spdlog.h" +#include "PR/ultra64/gbi.h" +#include +#include +#include +#include "MtxExporter.h" +#include +#include "VersionInfo.h" + +#define GFX_SIZE 8 + +#define gsDPSetCombineLERP2(a0, b0, c0, d0, Aa0, Ab0, Ac0, Ad0, \ + a1, b1, c1, d1, Aa1, Ab1, Ac1, Ad1) \ +{ \ + _SHIFTL(G_SETCOMBINE, 24, 8) | \ + _SHIFTL(GCCc0w0(a0, c0, \ + Aa0, Ac0) | \ + GCCc1w0(a1, c1), 0, 24), \ + (unsigned int)(GCCc0w1(b0, d0, \ + Ab0, Ad0) | \ + GCCc1w1(b1, Aa1, \ + Ac1, d1, \ + 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), } + +#define gsSPBranchLessZraw3(dl) \ +{ _SHIFTL(G_RDPHALF_1,24,8), \ + (unsigned int)(dl), } + +#define gsDPWordLo(wordlo) \ + gsImmp1(G_RDPHALF_2, (unsigned int)(wordlo)) + +#define gsSPTextureRectangle2(xl, yl, xh, yh, tile) \ +{ (_SHIFTL(G_TEXRECT, 24, 8) | _SHIFTL(xh, 12, 12) | _SHIFTL(yh, 0, 12)),\ + (_SHIFTL(tile, 24, 3) | _SHIFTL(xl, 12, 12) | _SHIFTL(yl, 0, 12)) } + +void OTRExporter_DisplayList::Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer) +{ + ZDisplayList* dList = (ZDisplayList*)res; + + //printf("Exporting DList %s\n", dList->GetName().c_str()); + + WriteHeader(res, outPath, writer, Ship::ResourceType::DisplayList); + + while (writer->GetBaseAddress() % 8 != 0) + writer->Write((uint8_t)0xFF); + + // 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()); + uint64_t hash = CRC64(dbgName.c_str()); + writer->Write((uint32_t)(G_MARKER << 24)); + writer->Write((uint32_t)0xBEEFBEEF); + writer->Write((uint32_t)(hash >> 32)); + writer->Write((uint32_t)(hash & 0xFFFFFFFF)); + + auto dlStart = std::chrono::steady_clock::now(); + + //for (auto data : dList->instructions) + for (int dataIdx = 0; dataIdx < dList->instructions.size(); dataIdx++) + { + auto data = dList->instructions[dataIdx]; + uint32_t word0 = 0; + uint32_t word1 = 0; + uint8_t opcode = (uint8_t)(data >> 56); + F3DZEXOpcode opF3D = (F3DZEXOpcode)opcode; + + if ((int)opF3D == G_DL)// || (int)opF3D == G_BRANCH_Z) + opcode = (uint8_t)G_DL_OTR; + + if ((int)opF3D == G_MTX) + opcode = (uint8_t)G_MTX_OTR; + + if ((int)opF3D == G_BRANCH_Z) + opcode = (uint8_t)G_BRANCH_Z_OTR; + + if ((int)opF3D == G_VTX) + opcode = (uint8_t)G_VTX_OTR; + + if ((int)opF3D == G_SETTIMG) + opcode = (uint8_t)G_SETTIMG_OTR; + + word0 += (opcode << 24); + + switch ((int)opF3D) + { + case G_NOOP: + { + Gfx value = gsDPNoOp(); + word0 = value.words.w0; + word1 = value.words.w1; + } + break; + case G_ENDDL: + { + Gfx value = gsSPEndDisplayList(); + word0 = value.words.w0; + word1 = value.words.w1; + } + break; + case G_MODIFYVTX: + { + int32_t ww = (data & 0x00FF000000000000ULL) >> 48; + int32_t nnnn = (data & 0x0000FFFF00000000ULL) >> 32; + int32_t vvvvvvvv = (data & 0x00000000FFFFFFFFULL); + + Gfx value = gsSPModifyVertex(nnnn / 2, ww, vvvvvvvv); + word0 = value.words.w0; + word1 = value.words.w1; + } + break; + default: + { + printf("Undefined opcode: %02X\n", opcode); + //word0 = _byteswap_ulong((uint32_t)(data >> 32)); + //word1 = _byteswap_ulong((uint32_t)(data & 0xFFFFFFFF)); + } + break; + case G_GEOMETRYMODE: + { + int32_t cccccc = (data & 0x00FFFFFF00000000) >> 32; + int32_t ssssssss = (data & 0xFFFFFFFF); + + Gfx value = gsSPGeometryMode(~cccccc, ssssssss); + word0 = value.words.w0; + word1 = value.words.w1; + } + break; + case G_RDPPIPESYNC: + { + Gfx value = gsDPPipeSync(); + word0 = value.words.w0; + word1 = value.words.w1; + } + break; + case G_RDPLOADSYNC: + { + Gfx value = gsDPLoadSync(); + word0 = value.words.w0; + word1 = value.words.w1; + } + break; + case G_RDPTILESYNC: + { + Gfx value = gsDPTileSync(); + word0 = value.words.w0; + word1 = value.words.w1; + } + break; + case G_RDPFULLSYNC: + { + Gfx value = gsDPFullSync(); + word0 = value.words.w0; + word1 = value.words.w1; + } + break; + case G_RDPSETOTHERMODE: + { + int32_t hhhhhh = (data & 0x00FFFFFF00000000) >> 32; + int32_t llllllll = (data & 0x00000000FFFFFFFF); + + Gfx value = gsDPSetOtherMode(hhhhhh, llllllll); + word0 = value.words.w0; + word1 = value.words.w1; + } + break; + case G_POPMTX: + { + Gfx value = gsSPPopMatrix(data); + word0 = value.words.w0; + word1 = value.words.w1; + } + break; + case G_SETENVCOLOR: + { + uint8_t r = (uint8_t)((data & 0xFF000000) >> 24); + uint8_t g = (uint8_t)((data & 0x00FF0000) >> 16); + uint8_t b = (uint8_t)((data & 0xFF00FF00) >> 8); + uint8_t a = (uint8_t)((data & 0x000000FF) >> 0); + + 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 + { + uint32_t pp = (data & 0x000000FF00000000) >> 32; + uint32_t mm = (data & 0x00000000FFFFFFFF); + + pp ^= G_MTX_PUSH; + + mm = (mm & 0x0FFFFFFF) + 0xF0000000; + + Gfx value = gsSPMatrix(mm, pp); + word0 = value.words.w0; + word1 = value.words.w1; + } + else + { + uint32_t pp = (data & 0x000000FF00000000) >> 32; + uint32_t mm = (data & 0x00000000FFFFFFFF); + pp ^= G_MTX_PUSH; + + Gfx value = gsSPMatrix(mm, pp); + word0 = value.words.w0; + word1 = value.words.w1; + + word0 = (word0 & 0x00FFFFFF) + (G_MTX_OTR << 24); + + Declaration* mtxDecl = dList->parent->GetDeclaration(GETSEGOFFSET(mm)); + + int bp = 0; + + writer->Write(word0); + writer->Write(word1); + + if (mtxDecl != nullptr) + { + std::string vName = StringHelper::Sprintf("%s\\%s", (GetParentFolderName(res).c_str()), mtxDecl->varName.c_str()); + + uint64_t hash = CRC64(vName.c_str()); + + word0 = hash >> 32; + word1 = hash & 0xFFFFFFFF; + } + else + { + word0 = 0; + word1 = 0; + spdlog::error(StringHelper::Sprintf("dListDecl == nullptr! Addr = {:08X}", GETSEGOFFSET(data))); + } + } + } + break; + case G_LOADBLOCK: + { + int32_t sss = (data & 0x00FFF00000000000) >> 48; + int32_t ttt = (data & 0x00000FFF00000000) >> 36; + int32_t i = (data & 0x000000000F000000) >> 24; + int32_t xxx = (data & 0x0000000000FFF000) >> 12; + int32_t ddd = (data & 0x0000000000000FFF); + + Gfx value = gsDPLoadBlock(i, sss, ttt, xxx, ddd); + word0 = value.words.w0; + word1 = value.words.w1; + } + break; + case G_CULLDL: + { + int32_t vvvv = (data & 0xFFFF00000000) >> 32; + int32_t wwww = (data & 0x0000FFFF); + + Gfx value = gsSPCullDisplayList(vvvv / 2, wwww / 2); + word0 = value.words.w0; + word1 = value.words.w1; + } + break; + case G_RDPHALF_1: + { + auto data2 = dList->instructions[dataIdx + 1]; + + if ((data2 >> 56) != G_BRANCH_Z) + { + uint32_t a = (data & 0x00FFF00000000000) >> 44; + uint32_t b = (data & 0x00000FFF00000000) >> 32; + uint32_t z = (data & 0x00000000FFFFFFFF) >> 0; + uint32_t h = (data & 0xFFFFFFFF); + + Gfx value = gsSPBranchLessZraw3(h & 0x00FFFFFF); + word0 = value.words.w0; + word1 = value.words.w1; + } + else + { + word0 = (G_NOOP << 24); + word1 = 0; + } + } + break; + case G_RDPHALF_2: + { + Gfx value = gsDPWordLo(data & 0xFFFFFFFF); + word0 = value.words.w0; + word1 = value.words.w1; + } + break; + case G_TEXRECT: + { + int32_t xxx = (data & 0x00FFF00000000000) >> 44; + int32_t yyy = (data & 0x00000FFF00000000) >> 32; + int32_t i = (data & 0x000000000F000000) >> 24; + int32_t XXX = (data & 0x0000000000FFF000) >> 12; + int32_t YYY = (data & 0x0000000000000FFF); + + Gfx value = gsSPTextureRectangle2(XXX, YYY, xxx, yyy, i); + word0 = value.words.w0; + word1 = value.words.w1; + } + break; + case G_BRANCH_Z: + { + uint32_t a = (data & 0x00FFF00000000000) >> 44; + uint32_t b = (data & 0x00000FFF00000000) >> 32; + uint32_t z = (data & 0x00000000FFFFFFFF) >> 0; + uint32_t h = (data & 0xFFFFFFFF); + + auto data2 = dList->instructions[dataIdx - 1]; + uint32_t dListPtr = GETSEGOFFSET(data2); + + Declaration* dListDecl = dList->parent->GetDeclaration(dListPtr); + + int bp = 0; + + Gfx value = gsSPBranchLessZraw2(0xDEADABCD, (a / 5) | (b / 2), z); + word0 = (value.words.w0 & 0x00FFFFFF) + (G_BRANCH_Z_OTR << 24); + word1 = value.words.w1; + + writer->Write(word0); + writer->Write(word1); + + if (dListDecl != nullptr) + { + std::string vName = StringHelper::Sprintf("%s\\%s", (GetParentFolderName(res).c_str()), dListDecl->varName.c_str()); + + uint64_t hash = CRC64(vName.c_str()); + + word0 = hash >> 32; + word1 = hash & 0xFFFFFFFF; + } + else + { + word0 = 0; + word1 = 0; + spdlog::error(StringHelper::Sprintf("dListDecl == nullptr! Addr = {:08X}", GETSEGOFFSET(data))); + } + + for (size_t i = 0; i < dList->otherDLists.size(); i++) + { + Declaration* dListDecl2 = dList->parent->GetDeclaration(GETSEGOFFSET(dList->otherDLists[i]->GetRawDataIndex())); + + if (dListDecl2 != nullptr) + { + //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)) + { + 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()); + } + } + else + { + spdlog::error(StringHelper::Sprintf("dListDecl2 == nullptr! Addr = {:08X}", GETSEGOFFSET(data))); + } + } + + //Gfx value = gsSPBranchLessZraw2(h & 0x00FFFFFF, (a / 5) | (b / 2), z); + //word0 = value.words.w0; + //word1 = value.words.w1; + } + break; + //case G_BRANCH_Z: + case G_DL: + { + if ((!Globals::Instance->HasSegment(GETSEGNUM(data)) && (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; + + if (pp != 0) + value = gsSPBranchList(dListVal); + else + value = gsSPDisplayList(dListVal); + + word0 = value.words.w0; + word1 = value.words.w1; + } + else + { + uint32_t dListPtr = GETSEGOFFSET(data); + + if ((int)opF3D == G_BRANCH_Z) + { + auto data2 = dList->instructions[dataIdx - 1]; + dListPtr = GETSEGOFFSET(data2); + } + else + { + int bp = 0; + } + + Declaration* dListDecl = dList->parent->GetDeclaration(dListPtr); + + int bp = 0; + + writer->Write(word0); + writer->Write(word1); + + if (dListDecl != nullptr) + { + std::string vName = StringHelper::Sprintf("%s\\%s", (GetParentFolderName(res).c_str()), dListDecl->varName.c_str()); + + uint64_t hash = CRC64(vName.c_str()); + + word0 = hash >> 32; + word1 = hash & 0xFFFFFFFF; + } + else + { + word0 = 0; + word1 = 0; + spdlog::error(StringHelper::Sprintf("dListDecl == nullptr! Addr = {:08X}", GETSEGOFFSET(data))); + } + + for (size_t i = 0; i < dList->otherDLists.size(); i++) + { + Declaration* dListDecl2 = dList->parent->GetDeclaration(GETSEGOFFSET(dList->otherDLists[i]->GetRawDataIndex())); + + if (dListDecl2 != nullptr) + { + //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)) + { + MemoryStream* dlStream = new MemoryStream(); + BinaryWriter dlWriter = BinaryWriter(dlStream); + + Save(dList->otherDLists[i], outPath, &dlWriter); + + File::WriteAllBytes("Extract\\" + fName, dlStream->ToVector()); + } + } + else + { + spdlog::error(StringHelper::Sprintf("dListDecl2 == nullptr! Addr = {:08X}", GETSEGOFFSET(data))); + } + } + } + } + break; + case G_TEXTURE: + { + int32_t ____ = (data & 0x0000FFFF00000000) >> 32; + int32_t ssss = (data & 0x00000000FFFF0000) >> 16; + int32_t tttt = (data & 0x000000000000FFFF); + int32_t lll = (____ & 0x3800) >> 11; + int32_t ddd = (____ & 0x700) >> 8; + int32_t nnnnnnn = (____ & 0xFE) >> 1; + + Gfx value = gsSPTexture(ssss, tttt, lll, ddd, nnnnnnn); + word0 = value.words.w0; + word1 = value.words.w1; + } + break; + case G_TRI1: + { + int32_t aa = ((data & 0x00FF000000000000ULL) >> 48) / 2; + int32_t bb = ((data & 0x0000FF0000000000ULL) >> 40) / 2; + int32_t cc = ((data & 0x000000FF00000000ULL) >> 32) / 2; + + Gfx test = gsSP1Triangle(aa, bb, cc, 0); + word0 = test.words.w0; + word1 = test.words.w1; + } + break; + case G_TRI2: + { + int32_t aa = ((data & 0x00FF000000000000ULL) >> 48) / 2; + int32_t bb = ((data & 0x0000FF0000000000ULL) >> 40) / 2; + int32_t cc = ((data & 0x000000FF00000000ULL) >> 32) / 2; + int32_t dd = ((data & 0x00000000FF0000ULL) >> 16) / 2; + 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); + word0 = test.words.w0; + word1 = test.words.w1; + } + break; + case G_QUAD: + { + int32_t aa = ((data & 0x00FF000000000000ULL) >> 48) / 2; + 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); + word0 = test.words.w0; + word1 = test.words.w1; + } + break; + case G_SETPRIMCOLOR: + { + int32_t mm = (data & 0x0000FF0000000000) >> 40; + int32_t ff = (data & 0x000000FF00000000) >> 32; + int32_t rr = (data & 0x00000000FF000000) >> 24; + int32_t gg = (data & 0x0000000000FF0000) >> 16; + int32_t bb = (data & 0x000000000000FF00) >> 8; + int32_t aa = (data & 0x00000000000000FF) >> 0; + + Gfx value = gsDPSetPrimColor(mm, ff, rr, gg, bb, aa); + word0 = value.words.w0; + word1 = value.words.w1; + } + break; + case G_SETOTHERMODE_L: + { + int32_t ss = (data & 0x0000FF0000000000) >> 40; + int32_t len = ((data & 0x000000FF00000000) >> 32) + 1; + int32_t sft = 32 - (len)-ss; + int32_t dd = (data & 0xFFFFFFFF); + + // TODO: Output the correct render modes in data + + Gfx value = gsSPSetOtherMode(0xE2, sft, len, dd); + word0 = value.words.w0; + word1 = value.words.w1; + } + break; + case G_SETOTHERMODE_H: + { + int32_t ss = (data & 0x0000FF0000000000) >> 40; + int32_t nn = (data & 0x000000FF00000000) >> 32; + int32_t dd = (data & 0xFFFFFFFF); + + int32_t sft = 32 - (nn + 1) - ss; + + Gfx value; + + 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); + } + else + { + value = gsSPSetOtherMode(0xE3, sft, nn + 1, dd); + } + + word0 = value.words.w0; + word1 = value.words.w1; + } + break; + case G_SETTILE: + { + int32_t fff = (data & 0b0000000011100000000000000000000000000000000000000000000000000000) >> 53; + int32_t ii = (data & 0b0000000000011000000000000000000000000000000000000000000000000000) >> 51; + int32_t nnnnnnnnn = + (data & 0b0000000000000011111111100000000000000000000000000000000000000000) >> 41; + int32_t mmmmmmmmm = + (data & 0b0000000000000000000000011111111100000000000000000000000000000000) >> 32; + int32_t ttt = (data & 0b0000000000000000000000000000000000000111000000000000000000000000) >> 24; + int32_t pppp = + (data & 0b0000000000000000000000000000000000000000111100000000000000000000) >> 20; + int32_t cc = (data & 0b0000000000000000000000000000000000000000000011000000000000000000) >> 18; + int32_t aaaa = + (data & 0b0000000000000000000000000000000000000000000000111100000000000000) >> 14; + int32_t ssss = + (data & 0b0000000000000000000000000000000000000000000000000011110000000000) >> 10; + int32_t dd = (data & 0b0000000000000000000000000000000000000000000000000000001100000000) >> 8; + 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); + word0 = value.words.w0; + word1 = value.words.w1; + } + break; + case G_SETCOMBINE: + { + int32_t a0 = (data & 0b000000011110000000000000000000000000000000000000000000000000000) >> 52; + int32_t c0 = (data & 0b000000000001111100000000000000000000000000000000000000000000000) >> 47; + int32_t aa0 = (data & 0b00000000000000011100000000000000000000000000000000000000000000) >> 44; + int32_t ac0 = (data & 0b00000000000000000011100000000000000000000000000000000000000000) >> 41; + int32_t a1 = (data & 0b000000000000000000000011110000000000000000000000000000000000000) >> 37; + int32_t c1 = (data & 0b000000000000000000000000001111100000000000000000000000000000000) >> 32; + int32_t b0 = (data & 0b000000000000000000000000000000011110000000000000000000000000000) >> 28; + int32_t b1 = (data & 0b000000000000000000000000000000000001111000000000000000000000000) >> 24; + int32_t aa1 = (data & 0b00000000000000000000000000000000000000111000000000000000000000) >> 21; + int32_t ac1 = (data & 0b00000000000000000000000000000000000000000111000000000000000000) >> 18; + int32_t d0 = (data & 0b000000000000000000000000000000000000000000000111000000000000000) >> 15; + int32_t ab0 = (data & 0b00000000000000000000000000000000000000000000000111000000000000) >> 12; + int32_t ad0 = (data & 0b00000000000000000000000000000000000000000000000000111000000000) >> 9; + int32_t d1 = (data & 0b000000000000000000000000000000000000000000000000000000111000000) >> 6; + 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); + word0 = value.words.w0; + word1 = value.words.w1; + } + break; + case G_SETTILESIZE: + { + int32_t sss = (data & 0x00FFF00000000000) >> 44; + int32_t ttt = (data & 0x00000FFF00000000) >> 32; + int32_t uuu = (data & 0x0000000000FFF000) >> 12; + int32_t vvv = (data & 0x0000000000000FFF); + int32_t i = (data & 0x000000000F000000) >> 24; + + Gfx value = gsDPSetTileSize(i, sss, ttt, uuu, vvv); + word0 = value.words.w0; + word1 = value.words.w1; + } + break; + case G_LOADTLUT: + { + int32_t t = (data & 0x0000000007000000) >> 24; + int32_t ccc = (data & 0x00000000003FF000) >> 14; + + Gfx value = gsDPLoadTLUTCmd(t, ccc); + word0 = value.words.w0; + word1 = value.words.w1; + } + break; + case G_LOADTILE: + { + int sss = (data & 0x00FFF00000000000) >> 44; + int ttt = (data & 0x00000FFF00000000) >> 32; + int i = (data & 0x000000000F000000) >> 16; + int uuu = (data & 0x0000000000FFF000) >> 12; + int vvv= (data & 0x0000000000000FFF); + + Gfx value = gsDPLoadTile(i, sss, ttt, uuu, vvv); + word0 = value.words.w0; + word1 = value.words.w1; + } + break; + case G_SETTIMG: + { + uint32_t seg = data & 0xFFFFFFFF; + int32_t texAddress = Seg2Filespace(data, dList->parent->baseAddress); + + if (!Globals::Instance->HasSegment(GETSEGNUM(seg))) + { + 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); + word0 = value.words.w0; + word1 = value.words.w1; + + writer->Write(word0); + writer->Write(word1); + } + else + { + std::string texName = ""; + bool foundDecl = Globals::Instance->GetSegmentedPtrName(seg, dList->parent, "", texName); + + 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, __); + word0 = value.words.w0 & 0x00FFFFFF; + word0 += (G_SETTIMG_OTR << 24); + //word1 = value.words.w1; + word1 = 0; + + writer->Write(word0); + writer->Write(word1); + + if (foundDecl) + { + ZFile* assocFile = Globals::Instance->GetSegment(GETSEGNUM(seg)); + std::string assocFileName = assocFile->GetName(); + std::string fName = ""; + + if (GETSEGNUM(seg) == SEGMENT_SCENE || GETSEGNUM(seg) == SEGMENT_ROOM) + fName = GetPathToRes(res, texName.c_str()); + else + fName = GetPathToRes(assocFile->resources[0], texName.c_str()); + + uint64_t hash = CRC64(fName.c_str()); + + word0 = hash >> 32; + word1 = hash & 0xFFFFFFFF; + } + else + { + word0 = 0; + word1 = 0; + spdlog::error("texDecl == nullptr! PTR = 0x{:08X}", texAddress); + } + } + } + break; + case G_VTX: + { + if (GETSEGNUM(data) == 0xC || GETSEGNUM(data) == 0x8) + { + // hack for dynamic verticies used in en_ganon_mant and en_jsjutan + // TODO is there a better way? + int32_t aa = (data & 0x000000FF00000000ULL) >> 32; + int32_t nn = (data & 0x000FF00000000000ULL) >> 44; + + Gfx value = gsSPVertex(data & 0xFFFFFFFF, nn, ((aa >> 1) - nn)); + + word0 = value.words.w0; + word1 = value.words.w1 | 0xF0000000; + } + else + //if (dList->vertices.size() > 0) + { + // Connect neighboring vertex arrays + std::vector>> 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; + + if (GETSEGNUM(data) == 0x80) + 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; + + if (vtxDecl != nullptr && vtxDecl->varType != "Gfx") + { + uint32_t diff = segOffset - vtxDecl->address; + + Gfx value = gsSPVertex(diff, nn, ((aa >> 1) - nn)); + + word0 = value.words.w0; + word0 &= 0x00FFFFFF; + word0 += (G_VTX_OTR << 24); + word1 = value.words.w1; + + writer->Write(word0); + writer->Write(word1); + + std::string fName = OTRExporter_DisplayList::GetPathToRes(res, vtxDecl->varName); + + uint64_t hash = CRC64(fName.c_str()); + + word0 = hash >> 32; + word1 = hash & 0xFFFFFFFF; + + if (!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); + + int arrCnt = 0; + + auto split = StringHelper::Split(vtxDecl->text, "\n"); + + for (int i = 0; i < split.size(); i++) + { + std::string line = split[i]; + + if (StringHelper::Contains(line, "VTX(")) + arrCnt++; + } + + // OTRTODO: Once we aren't relying on text representations, we should call ArrayExporter... + OTRExporter::WriteHeader(nullptr, "", &vtxWriter, Ship::ResourceType::Array); + + vtxWriter.Write((uint32_t)ZResourceType::Vertex); + vtxWriter.Write((uint32_t)arrCnt); + + size_t sz = dList->vertices[vtxDecl->address].size(); + + //if (sz > 0) + { + auto start = std::chrono::steady_clock::now(); + + // God dammit this is so dumb + for (size_t i = 0; i < split.size(); i++) + { + std::string line = split[i]; + + 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)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 + } + } + + File::WriteAllBytes("Extract\\" + fName, vtxStream->ToVector()); + + auto end = std::chrono::steady_clock::now(); + size_t diff = std::chrono::duration_cast(end - start).count(); + + //printf("Exported VTX Array %s in %zums\n", fName.c_str(), diff); + } + } + } + else + { + 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); + } + + auto dlEnd = std::chrono::steady_clock::now(); + size_t dlDiff = std::chrono::duration_cast(dlEnd - dlStart).count(); + + //printf("Display List Gen in %zums\n", dlDiff); +} + +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()); + + return fName; +} + +std::string OTRExporter_DisplayList::GetParentFolderName(ZResource* res) +{ + std::string prefix = GetPrefix(res); + std::string oName = res->parent->GetOutName(); + + if (StringHelper::Contains(oName, "_scene")) + { + auto split = StringHelper::Split(oName, "_"); + oName = ""; + for (int i = 0; i < split.size() - 1; i++) + oName += split[i] + "_"; + + oName += "scene"; + } + else if (StringHelper::Contains(oName, "_room")) + { + oName = StringHelper::Split(oName, "_room")[0] + "_scene"; + } + + if (prefix != "") + oName = prefix + "\\" + oName; + + return oName; +} + +std::string OTRExporter_DisplayList::GetPrefix(ZResource* res) +{ + std::string oName = res->parent->GetOutName(); + std::string prefix = ""; + std::string xmlPath = StringHelper::Replace(res->parent->GetXmlFilePath().string(), "\\", "/"); + + if (StringHelper::Contains(oName, "_scene") || StringHelper::Contains(oName, "_room")) + prefix = "scenes"; + else if (StringHelper::Contains(xmlPath, "objects/")) + prefix = "objects"; + else if (StringHelper::Contains(xmlPath, "textures/")) + prefix = "textures"; + else if (StringHelper::Contains(xmlPath, "overlays/")) + prefix = "overlays"; + else if (StringHelper::Contains(xmlPath, "misc/")) + prefix = "misc"; + else if (StringHelper::Contains(xmlPath, "text/")) + prefix = "text"; + else if (StringHelper::Contains(xmlPath, "code/")) + prefix = "code"; + + return prefix; +} \ No newline at end of file diff --git a/OTRExporter/OTRExporter/DisplayListExporter.h b/OTRExporter/OTRExporter/DisplayListExporter.h new file mode 100644 index 000000000..d8d96971c --- /dev/null +++ b/OTRExporter/OTRExporter/DisplayListExporter.h @@ -0,0 +1,17 @@ +#pragma once + +#include "ZResource.h" +#include "ZTexture.h" +#include "ZDisplayList.h" +#include "Exporter.h" +#include + +class OTRExporter_DisplayList : public OTRExporter +{ +public: + virtual void Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer) override; + static std::string GetParentFolderName(ZResource* res); + static std::string GetPathToRes(ZResource* res, std::string varName); + static std::string GetPrefix(ZResource* res); + +}; \ No newline at end of file diff --git a/OTRExporter/OTRExporter/Exporter.cpp b/OTRExporter/OTRExporter/Exporter.cpp new file mode 100644 index 000000000..78c7ed3f4 --- /dev/null +++ b/OTRExporter/OTRExporter/Exporter.cpp @@ -0,0 +1,20 @@ +#include "Exporter.h" +#include "VersionInfo.h" + +void OTRExporter::WriteHeader(ZResource* res, const fs::path& outPath, BinaryWriter* writer, Ship::ResourceType resType) +{ + writer->Write((uint8_t)Endianess::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((uint64_t)0xDEADBEEFDEADBEEF); // id, 0x0C + writer->Write((uint32_t)resourceVersions[resType]); // 0x10 + writer->Write((uint64_t)0); // ROM CRC, 0x14 + writer->Write((uint32_t)0); // ROM Enum, 0x1C + + while (writer->GetBaseAddress() < 0x40) + writer->Write((uint32_t)0); // To be used at a later date! +} diff --git a/OTRExporter/OTRExporter/Exporter.h b/OTRExporter/OTRExporter/Exporter.h new file mode 100644 index 000000000..45681662a --- /dev/null +++ b/OTRExporter/OTRExporter/Exporter.h @@ -0,0 +1,12 @@ +#pragma once +#include "ZResource.h" +#include "ZArray.h" +//#include "OTRExporter.h" +#include +#include + +class OTRExporter : public ZResourceExporter +{ +protected: + static void WriteHeader(ZResource* res, const fs::path& outPath, BinaryWriter* writer, Ship::ResourceType resType); +}; \ No newline at end of file diff --git a/OTRExporter/OTRExporter/Main.cpp b/OTRExporter/OTRExporter/Main.cpp new file mode 100644 index 000000000..24a156fe9 --- /dev/null +++ b/OTRExporter/OTRExporter/Main.cpp @@ -0,0 +1,183 @@ +#include +#include "BackgroundExporter.h" +#include "TextureExporter.h" +#include "RoomExporter.h" +#include "CollisionExporter.h" +#include "DisplayListExporter.h" +#include "PlayerAnimationExporter.h" +#include "SkeletonExporter.h" +#include "SkeletonLimbExporter.h" +#include "ArrayExporter.h" +#include "VtxExporter.h" +#include "AnimationExporter.h" +#include "CutsceneExporter.h" +#include "PathExporter.h" +#include "TextExporter.h" +#include "BlobExporter.h" +#include "MtxExporter.h" +#include +#include +#include +#include +#include + +std::string otrFileName = "oot.otr"; +std::shared_ptr otrArchive; +BinaryWriter* fileWriter; +std::chrono::steady_clock::time_point fileStart, resStart; + +void InitVersionInfo(); + +enum class ExporterFileMode +{ + BuildOTR = (int)ZFileMode::Custom + 1, +}; + +static void ExporterParseFileMode(const std::string& buildMode, ZFileMode& fileMode) +{ + if (buildMode == "botr") + { + fileMode = (ZFileMode)ExporterFileMode::BuildOTR; + + if (File::Exists(otrFileName)) + otrArchive = std::shared_ptr(new Ship::Archive(otrFileName, true)); + else + otrArchive = Ship::Archive::CreateArchive(otrFileName, 65536 / 2); + + 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()); + } + } +} + +static void ExporterParseArgs(int argc, char* argv[], int& i) +{ + std::string arg = argv[i]; + + if (arg == "--otrfile") + { + otrFileName = argv[i + 1]; + i++; + } +} + +static bool ExporterProcessFileMode(ZFileMode fileMode) +{ + // Do whatever work is associated with these custom file modes... + // Return true to indicate one of our own file modes is being processed + if (fileMode == (ZFileMode)ExporterFileMode::BuildOTR) + return true; + + return false; +} + +static void ExporterFileBegin(ZFile* file) +{ + fileStart = std::chrono::steady_clock::now(); + + MemoryStream* stream = new MemoryStream(); + fileWriter = new BinaryWriter(stream); +} + +static void ExporterFileEnd(ZFile* file) +{ +} + +static void ExporterResourceEnd(ZResource* res, BinaryWriter& writer) +{ + auto streamShared = writer.GetStream(); + MemoryStream* strem = (MemoryStream*)streamShared.get(); + + auto start = std::chrono::steady_clock::now(); + + if (res->GetName() != "") + { + std::string oName = res->parent->GetOutName(); + std::string rName = res->GetName(); + std::string prefix = OTRExporter_DisplayList::GetPrefix(res); + + //auto xmlFilePath = res->parent->GetXmlFilePath(); + //prefix = StringHelper::Split(StringHelper::Split(xmlFilePath.string(), "xml\\")[1], ".xml")[0]; + + if (StringHelper::Contains(oName, "_scene")) + { + auto split = StringHelper::Split(oName, "_"); + oName = ""; + for (int i = 0; i < split.size() - 1; i++) + oName += split[i] + "_"; + + oName += "scene"; + } + else if (StringHelper::Contains(oName, "_room")) + { + oName = StringHelper::Split(oName, "_room")[0] + "_scene"; + } + + std::string fName = ""; + + if (prefix != "") + 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()); + + File::WriteAllBytes("Extract\\" + fName, strem->ToVector()); + } + + auto end = std::chrono::steady_clock::now(); + size_t diff = std::chrono::duration_cast(end - start).count(); + + //if (diff > 10) + //printf("Exported Resource End %s in %zums\n", res->GetName().c_str(), diff); +} + +static void ExporterXMLBegin() +{ +} + +static void ExporterXMLEnd() +{ +} + +static void ImportExporters() +{ + // In this example we set up a new exporter called "EXAMPLE". + // By running ZAPD with the argument -se EXAMPLE, we tell it that we want to use this exporter for our resources. + ExporterSet* exporterSet = new ExporterSet(); + exporterSet->processFileModeFunc = ExporterProcessFileMode; + exporterSet->parseFileModeFunc = ExporterParseFileMode; + exporterSet->parseArgsFunc = ExporterParseArgs; + exporterSet->beginFileFunc = ExporterFileBegin; + exporterSet->endFileFunc = ExporterFileEnd; + exporterSet->beginXMLFunc = ExporterXMLBegin; + exporterSet->endXMLFunc = ExporterXMLEnd; + exporterSet->resSaveFunc = ExporterResourceEnd; + exporterSet->exporters[ZResourceType::Background] = new OTRExporter_Background(); + exporterSet->exporters[ZResourceType::Texture] = new OTRExporter_Texture(); + exporterSet->exporters[ZResourceType::Room] = new OTRExporter_Room(); + exporterSet->exporters[ZResourceType::AltHeader] = new OTRExporter_Room(); + exporterSet->exporters[ZResourceType::Scene] = new OTRExporter_Room(); + exporterSet->exporters[ZResourceType::CollisionHeader] = new OTRExporter_Collision(); + exporterSet->exporters[ZResourceType::DisplayList] = new OTRExporter_DisplayList(); + exporterSet->exporters[ZResourceType::PlayerAnimationData] = new OTRExporter_PlayerAnimationExporter(); + exporterSet->exporters[ZResourceType::Skeleton] = new OTRExporter_Skeleton(); + exporterSet->exporters[ZResourceType::Limb] = new OTRExporter_SkeletonLimb(); + exporterSet->exporters[ZResourceType::Animation] = new OTRExporter_Animation(); + exporterSet->exporters[ZResourceType::Cutscene] = new OTRExporter_Cutscene(); + exporterSet->exporters[ZResourceType::Vertex] = new OTRExporter_Vtx(); + exporterSet->exporters[ZResourceType::Array] = new OTRExporter_Array(); + exporterSet->exporters[ZResourceType::Path] = new OTRExporter_Path(); + exporterSet->exporters[ZResourceType::Text] = new OTRExporter_Text(); + exporterSet->exporters[ZResourceType::Blob] = new OTRExporter_Blob(); + exporterSet->exporters[ZResourceType::Mtx] = new OTRExporter_MtxExporter(); + + Globals::AddExporter("OTR", exporterSet); + + InitVersionInfo(); +} + +// When ZAPD starts up, it will automatically call the below function, which in turn sets up our exporters. +REGISTER_EXPORTER(ImportExporters); diff --git a/OTRExporter/OTRExporter/Main.h b/OTRExporter/OTRExporter/Main.h new file mode 100644 index 000000000..a29e21859 --- /dev/null +++ b/OTRExporter/OTRExporter/Main.h @@ -0,0 +1,5 @@ +#pragma once + +#include + +extern std::shared_ptr otrArchive; \ No newline at end of file diff --git a/OTRExporter/OTRExporter/Makefile b/OTRExporter/OTRExporter/Makefile new file mode 100644 index 000000000..1c4e61bf2 --- /dev/null +++ b/OTRExporter/OTRExporter/Makefile @@ -0,0 +1,70 @@ +# 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) \ No newline at end of file diff --git a/OTRExporter/OTRExporter/MtxExporter.cpp b/OTRExporter/OTRExporter/MtxExporter.cpp new file mode 100644 index 000000000..a329c43a2 --- /dev/null +++ b/OTRExporter/OTRExporter/MtxExporter.cpp @@ -0,0 +1,13 @@ +#include "MtxExporter.h" + +void OTRExporter_MtxExporter::Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer) +{ + ZMtx* mtx = (ZMtx*)res; + + WriteHeader(res, outPath, writer, Ship::ResourceType::Matrix); + + for (size_t i = 0; i < 4; i++) + for (size_t j = 0; j < 4; j++) + //TODO possibly utilize the array class better + writer->Write(mtx->mtx[i][j]); +} \ No newline at end of file diff --git a/OTRExporter/OTRExporter/MtxExporter.h b/OTRExporter/OTRExporter/MtxExporter.h new file mode 100644 index 000000000..895f2a40e --- /dev/null +++ b/OTRExporter/OTRExporter/MtxExporter.h @@ -0,0 +1,10 @@ +#include "ZResource.h" +#include "ZMtx.h" +#include "Exporter.h" +#include + +class OTRExporter_MtxExporter : public OTRExporter +{ +public: + virtual void Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer) override; +}; diff --git a/OTRExporter/OTRExporter/OTRExporter.vcxproj b/OTRExporter/OTRExporter/OTRExporter.vcxproj new file mode 100644 index 000000000..96531304b --- /dev/null +++ b/OTRExporter/OTRExporter/OTRExporter.vcxproj @@ -0,0 +1,202 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 16.0 + Win32Proj + {a6103fd3-0709-4fc7-b066-1a6e056d6306} + OTRExporter + 10.0 + + + + StaticLibrary + true + v142 + Unicode + + + Application + false + v142 + true + Unicode + + + StaticLibrary + true + v142 + Unicode + + + StaticLibrary + false + v142 + true + Unicode + + + + + + + + + + + + + + + + + + + + + true + $(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) + + + false + + + true + $(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) + $(ProjectDir)..\..\libultraship\libultraship;$(LibraryPath) + + + false + $(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) + $(ProjectDir)..\..\libultraship\libultraship;$(LibraryPath) + + + + Level3 + true + WIN32;_DEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) + true + stdcpp17 + + + Console + true + + + + + Level3 + true + true + true + WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) + true + + + Console + true + true + true + + + + + Level3 + true + _DEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) + true + stdcpp17 + stdc11 + MultiThreadedDebug + + + Console + true + ZAPDUtils.lib;OTRLib.lib;%(AdditionalDependencies) + + + + + Level3 + true + true + true + NDEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) + true + stdcpp17 + stdc11 + MultiThreaded + + + Console + true + true + true + + + + + + \ No newline at end of file diff --git a/OTRExporter/OTRExporter/OTRExporter.vcxproj.filters b/OTRExporter/OTRExporter/OTRExporter.vcxproj.filters new file mode 100644 index 000000000..8ecc347dc --- /dev/null +++ b/OTRExporter/OTRExporter/OTRExporter.vcxproj.filters @@ -0,0 +1,144 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + \ No newline at end of file diff --git a/OTRExporter/OTRExporter/PathExporter.cpp b/OTRExporter/OTRExporter/PathExporter.cpp new file mode 100644 index 000000000..de15789ab --- /dev/null +++ b/OTRExporter/OTRExporter/PathExporter.cpp @@ -0,0 +1,23 @@ +#include "PathExporter.h" +#include "../ZAPD/ZFile.h" + +void OTRExporter_Path::Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer) +{ + ZPath* path = (ZPath*)res; + + WriteHeader(res, outPath, writer, Ship::ResourceType::Path); + + writer->Write((uint32_t)path->pathways.size()); + + for (int 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++) + { + writer->Write(path->pathways[k].points[i].scalars[0].scalarData.s16); + writer->Write(path->pathways[k].points[i].scalars[1].scalarData.s16); + writer->Write(path->pathways[k].points[i].scalars[2].scalarData.s16); + } + } +} \ No newline at end of file diff --git a/OTRExporter/OTRExporter/PathExporter.h b/OTRExporter/OTRExporter/PathExporter.h new file mode 100644 index 000000000..9614b84df --- /dev/null +++ b/OTRExporter/OTRExporter/PathExporter.h @@ -0,0 +1,12 @@ +#pragma once + +#include "ZResource.h" +#include "ZPath.h" +#include "Exporter.h" +#include + +class OTRExporter_Path : public OTRExporter +{ +public: + virtual void Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer) override; +}; \ No newline at end of file diff --git a/OTRExporter/OTRExporter/PlayerAnimationExporter.cpp b/OTRExporter/OTRExporter/PlayerAnimationExporter.cpp new file mode 100644 index 000000000..9b65f199b --- /dev/null +++ b/OTRExporter/OTRExporter/PlayerAnimationExporter.cpp @@ -0,0 +1,21 @@ +#include "PlayerAnimationExporter.h" +#include + +void OTRExporter_PlayerAnimationExporter::Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer) +{ + ZPlayerAnimationData* anim = (ZPlayerAnimationData*)res; + + WriteHeader(res, outPath, writer, Ship::ResourceType::PlayerAnimation); + + auto start = std::chrono::steady_clock::now(); + + writer->Write((uint32_t)anim->limbRotData.size()); + + for (size_t i = 0; i < anim->limbRotData.size(); i++) + writer->Write(anim->limbRotData[i]); + + auto end = std::chrono::steady_clock::now(); + size_t diff = std::chrono::duration_cast(end - start).count(); + + //printf("Exported Player Anim %s in %zums\n", anim->GetName().c_str(), diff); +} diff --git a/OTRExporter/OTRExporter/PlayerAnimationExporter.h b/OTRExporter/OTRExporter/PlayerAnimationExporter.h new file mode 100644 index 000000000..49e5468a2 --- /dev/null +++ b/OTRExporter/OTRExporter/PlayerAnimationExporter.h @@ -0,0 +1,13 @@ +#pragma once + +#include "ZResource.h" +#include "ZTexture.h" +#include "ZPlayerAnimationData.h" +#include "Exporter.h" +#include + +class OTRExporter_PlayerAnimationExporter : public OTRExporter +{ +public: + virtual void Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer) override; +}; \ No newline at end of file diff --git a/OTRExporter/OTRExporter/RoomExporter.cpp b/OTRExporter/OTRExporter/RoomExporter.cpp new file mode 100644 index 000000000..622901aff --- /dev/null +++ b/OTRExporter/OTRExporter/RoomExporter.cpp @@ -0,0 +1,530 @@ +#include "RoomExporter.h" +#include "Utils/BinaryWriter.h" +#include "Utils/MemoryStream.h" +#include "Utils/File.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "CollisionExporter.h" +#include "DisplayListExporter.h" +#include "Resource.h" +#include +#include +#include +#include "TextureExporter.h" +#include "Main.h" +#include +#include "CutsceneExporter.h" +#include +#include "PathExporter.h" +#undef FindResource + +void OTRExporter_Room::Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer) +{ + ZRoom* room = (ZRoom*)res; + + WriteHeader(res, outPath, writer, Ship::ResourceType::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) + { + case RoomCommand::SetTransitionActorList: + { + SetTransitionActorList* cmdTrans = (SetTransitionActorList*)cmd; + + writer->Write((uint32_t)cmdTrans->transitionActors.size()); + + for (const TransitionActorEntry& entry : cmdTrans->transitionActors) + { + writer->Write(entry.frontObjectRoom); + writer->Write(entry.frontTransitionReaction); + writer->Write(entry.backObjectRoom); + writer->Write(entry.backTransitionReaction); + writer->Write(entry.actorNum); + writer->Write(entry.posX); + writer->Write(entry.posY); + writer->Write(entry.posZ); + writer->Write(entry.rotY); + writer->Write(entry.initVar); + } + } + break; + case RoomCommand::SetActorList: + { + SetActorList* cmdSetActorList = (SetActorList*)cmd; + + // There are instance of the amount of actors in the file differing from the size listed in the command. + // This can cause issues if we export actors with garbage data, so let's trust the command size + writer->Write((uint32_t)cmdSetActorList->numActors); + + for (int i = 0; i < cmdSetActorList->numActors; i++) + { + const ActorSpawnEntry& entry = cmdSetActorList->actors[i]; + + writer->Write(entry.actorNum); + writer->Write(entry.posX); + writer->Write(entry.posY); + writer->Write(entry.posZ); + writer->Write(entry.rotX); + writer->Write(entry.rotY); + writer->Write(entry.rotZ); + writer->Write(entry.initVar); + } + } + break; + case RoomCommand::SetWind: + { + SetWind* cmdSetWind = (SetWind*)cmd; + + writer->Write(cmdSetWind->windWest); // 0x04 + writer->Write(cmdSetWind->windVertical); // 0x05 + writer->Write(cmdSetWind->windSouth); // 0x06 + writer->Write(cmdSetWind->clothFlappingStrength); // 0x07 + } + break; + case RoomCommand::SetTimeSettings: + { + SetTimeSettings* cmdTime = (SetTimeSettings*)cmd; + + writer->Write(cmdTime->hour); // 0x04 + writer->Write(cmdTime->min); // 0x05 + writer->Write(cmdTime->unk); // 0x06 + } + break; + case RoomCommand::SetSkyboxModifier: + { + SetSkyboxModifier* cmdSkybox = (SetSkyboxModifier*)cmd; + + writer->Write(cmdSkybox->disableSky); // 0x04 + writer->Write(cmdSkybox->disableSunMoon); // 0x05 + } + break; + case RoomCommand::SetEchoSettings: + { + SetEchoSettings* cmdEcho = (SetEchoSettings*)cmd; + + writer->Write((uint8_t)cmdEcho->echo); // 0x07 + } + break; + case RoomCommand::SetSoundSettings: + { + SetSoundSettings* cmdSound = (SetSoundSettings*)cmd; + + writer->Write((uint8_t)cmdSound->reverb); // 0x01 + + writer->Write(cmdSound->nightTimeSFX); // 0x06 + writer->Write(cmdSound->musicSequence); // 0x07 + } + break; + case RoomCommand::SetSkyboxSettings: + { + SetSkyboxSettings* cmdSkybox = (SetSkyboxSettings*)cmd; + + writer->Write((uint8_t)cmdSkybox->unk1); // 0x01 + writer->Write((uint8_t)cmdSkybox->skyboxNumber); // 0x04 + writer->Write((uint8_t)cmdSkybox->cloudsType); // 0x05 + writer->Write((uint8_t)cmdSkybox->isIndoors); // 0x06 + } + break; + case RoomCommand::SetRoomBehavior: + { + SetRoomBehavior* cmdRoom = (SetRoomBehavior*)cmd; + + writer->Write((uint8_t)cmdRoom->gameplayFlags); // 0x01 + writer->Write(cmdRoom->gameplayFlags2); // 0x04 + } + break; + case RoomCommand::SetCsCamera: + { + SetCsCamera* cmdCsCam = (SetCsCamera*)cmd; + + writer->Write((uint32_t)cmdCsCam->cameras.size()); + + for (size_t i = 0; i < cmdCsCam->cameras.size(); i++) + { + writer->Write(cmdCsCam->cameras[i].baseOffset); + writer->Write(cmdCsCam->cameras[i].type); + writer->Write(cmdCsCam->cameras[i].numPoints); + } + + writer->Write((uint32_t)cmdCsCam->points.size()); + + for (int 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); + writer->Write(cmdCsCam->points[i].scalars[2].scalarData.s16); + } + } + break; + case RoomCommand::SetMesh: + { + SetMesh* cmdMesh = (SetMesh*)cmd; + + writer->Write((uint8_t)cmdMesh->data); // 0x01 + writer->Write(cmdMesh->meshHeaderType); + + if (cmdMesh->meshHeaderType == 0 || cmdMesh->meshHeaderType == 2) + { + PolygonType2* poly = (PolygonType2*)cmdMesh->polyType.get(); + + writer->Write(poly->num); + + for (int i = 0; i < poly->num; i++) + WritePolyDList(writer, room, &poly->polyDLists[i]); + } + else if (cmdMesh->meshHeaderType == 1) + { + PolygonType1* poly = (PolygonType1*)cmdMesh->polyType.get(); + + writer->Write(poly->format); + + auto test = (PolygonDlist*)&poly->polyDLists[0]; + Declaration* dListDeclOpa = poly->parent->GetDeclaration(GETSEGOFFSET(test->opa)); + 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())); + else + writer->Write(""); + + if (test->xlu != 0) + writer->Write(StringHelper::Sprintf("%s\\%s", OTRExporter_DisplayList::GetParentFolderName(res).c_str(), dListDeclXlu->varName.c_str())); + else + writer->Write(""); + + if (poly->format == 2) + { + writer->Write((uint32_t)poly->count); + + for (int i = 0; i < poly->count; i++) + { + writer->Write(poly->multiList[i].unk_00); + writer->Write(poly->multiList[i].id); + + 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); + writer->Write(poly->multiList[i].height); + writer->Write(poly->multiList[i].fmt); + writer->Write(poly->multiList[i].siz); + writer->Write(poly->multiList[i].mode0); + writer->Write(poly->multiList[i].tlutCount); + } + } + else + { + writer->Write((uint32_t)1); + + writer->Write(poly->single.unk_00); + writer->Write(poly->single.id); + + Declaration* bgDecl = poly->parent->GetDeclarationRanged(GETSEGOFFSET(poly->single.source)); + + writer->Write(OTRExporter_DisplayList::GetPathToRes(poly->single.sourceBackground, bgDecl->varName)); + + writer->Write(poly->single.unk_0C); + writer->Write(poly->single.tlut); + writer->Write(poly->single.width); + writer->Write(poly->single.height); + writer->Write(poly->single.fmt); + writer->Write(poly->single.siz); + writer->Write(poly->single.mode0); + writer->Write(poly->single.tlutCount); + } + + if (poly->dlist != 0) + WritePolyDList(writer, room, &poly->polyDLists[0]); + } + } + break; + case RoomCommand::SetCameraSettings: + { + SetCameraSettings* cmdCam = (SetCameraSettings*)cmd; + + writer->Write((uint8_t)cmdCam->cameraMovement); // 0x01 + writer->Write(cmdCam->mapHighlight); // 0x04 + } + break; + case RoomCommand::SetLightList: + { + SetLightList* cmdLight = (SetLightList*)cmd; + + writer->Write((uint32_t)cmdLight->lights.size()); + + for (size_t i = 0; i < cmdLight->lights.size(); i++) + { + writer->Write(cmdLight->lights[i].type); + writer->Write(cmdLight->lights[i].x); + writer->Write(cmdLight->lights[i].y); + writer->Write(cmdLight->lights[i].z); + writer->Write(cmdLight->lights[i].r); + writer->Write(cmdLight->lights[i].g); + writer->Write(cmdLight->lights[i].b); + writer->Write(cmdLight->lights[i].drawGlow); + writer->Write(cmdLight->lights[i].radius); + } + } + break; + case RoomCommand::SetLightingSettings: + { + SetLightingSettings* cmdLight = (SetLightingSettings*)cmd; + + writer->Write((uint32_t)cmdLight->settings.size()); // 0x01 + + for (const LightingSettings& setting : cmdLight->settings) + { + writer->Write(setting.ambientClrR); + writer->Write(setting.ambientClrG); + writer->Write(setting.ambientClrB); + + writer->Write(setting.diffuseClrA_R); + writer->Write(setting.diffuseClrA_G); + writer->Write(setting.diffuseClrA_B); + + writer->Write(setting.diffuseDirA_X); + writer->Write(setting.diffuseDirA_Y); + writer->Write(setting.diffuseDirA_Z); + + writer->Write(setting.diffuseClrB_R); + writer->Write(setting.diffuseClrB_G); + writer->Write(setting.diffuseClrB_B); + + writer->Write(setting.diffuseDirB_X); + writer->Write(setting.diffuseDirB_Y); + writer->Write(setting.diffuseDirB_Z); + + writer->Write(setting.fogClrR); + writer->Write(setting.fogClrG); + writer->Write(setting.fogClrB); + + writer->Write(setting.unk); + writer->Write(setting.drawDistance); + } + } + break; + case RoomCommand::SetRoomList: + { + SetRoomList* cmdRoom = (SetRoomList*)cmd; + + writer->Write((uint32_t)cmdRoom->romfile->numRooms); // 0x01 + + 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 = 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); + writer->Write(cmdRoom->romfile->rooms[i].virtualAddressEnd); + } + } + break; + case RoomCommand::SetCollisionHeader: + { + SetCollisionHeader* cmdCollHeader = (SetCollisionHeader*)cmd; + + Declaration* colHeaderDecl = room->parent->GetDeclaration(cmdCollHeader->segmentOffset); + std::string path = OTRExporter_DisplayList::GetPathToRes(room, colHeaderDecl->varName); + writer->Write(path); + } + break; + case RoomCommand::SetEntranceList: + { + SetEntranceList* cmdEntrance = (SetEntranceList*)cmd; + + writer->Write((uint32_t)cmdEntrance->entrances.size()); + + for (EntranceEntry entry : cmdEntrance->entrances) + { + writer->Write((uint8_t)entry.startPositionIndex); + writer->Write((uint8_t)entry.roomToLoad); + } + } + break; + case RoomCommand::SetSpecialObjects: + { + SetSpecialObjects* cmdSpecObj = (SetSpecialObjects*)cmd; + + writer->Write((uint8_t)cmdSpecObj->elfMessage); // 0x01 + writer->Write((uint16_t)cmdSpecObj->globalObject); // 0x06 + } + break; + case RoomCommand::SetStartPositionList: + { + SetStartPositionList* cmdStartPos = (SetStartPositionList*)cmd; + + 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); + writer->Write(entry.posX); + writer->Write(entry.posY); + writer->Write(entry.posZ); + writer->Write(entry.rotX); + writer->Write(entry.rotY); + writer->Write(entry.rotZ); + writer->Write(entry.initVar); + } + } + break; + case RoomCommand::SetAlternateHeaders: + { + SetAlternateHeaders* cmdHeaders = (SetAlternateHeaders*)cmd; + + writer->Write((uint32_t)cmdHeaders->headers.size()); + + for (size_t i = 0; i < cmdHeaders->headers.size(); i++) + { + uint32_t seg = cmdHeaders->headers[i] & 0xFFFFFFFF; + std::string headerName = ""; + bool foundDecl = Globals::Instance->GetSegmentedPtrName(seg, room->parent, "", headerName); + if (headerName == "NULL") + writer->Write(""); + else + { + std::string name = OTRExporter_DisplayList::GetPathToRes(room, headerName); + writer->Write(name); + } + } + } + break; + case RoomCommand::SetExitList: + { + SetExitList* cmdExit = (SetExitList*)cmd; + + writer->Write((uint32_t)cmdExit->exits.size()); + + for (size_t i = 0; i < cmdExit->exits.size(); i++) + writer->Write(cmdExit->exits[i]); + } + break; + case RoomCommand::SetObjectList: + { + SetObjectList* cmdSetObjectList = (SetObjectList*)cmd; + + writer->Write((uint32_t)cmdSetObjectList->objects.size()); + + for (size_t i = 0; i < cmdSetObjectList->objects.size(); i++) + writer->Write(cmdSetObjectList->objects[i]); + } + break; + case RoomCommand::SetCutscenes: + { + SetCutscenes* cmdSetCutscenes = (SetCutscenes*)cmd; + + std::string listName; + Globals::Instance->GetSegmentedPtrName(cmdSetCutscenes->cmdArg2, room->parent, "CutsceneData", listName); + 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); + + MemoryStream* csStream = new MemoryStream(); + BinaryWriter csWriter = BinaryWriter(csStream); + 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()); + } + break; + case RoomCommand::SetPathways: + { + SetPathways* cmdSetPathways = (SetPathways*)cmd; + + writer->Write((uint32_t)cmdSetPathways->pathwayList.pathways.size()); + + for (int 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()); + std::string path = OTRExporter_DisplayList::GetPathToRes(room, decl->varName); + writer->Write(path); + + MemoryStream* pathStream = new MemoryStream(); + BinaryWriter pathWriter = BinaryWriter(pathStream); + 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; + } + } + break; + case RoomCommand::EndMarker: + break; + default: + printf("UNIMPLEMENTED COMMAND: 0x%02X\n", (int)cmd->cmdID); + + break; + } + } +} + +void OTRExporter_Room::WritePolyDList(BinaryWriter* writer, ZRoom* room, PolygonDlist* dlist) +{ + writer->Write(dlist->polyType); + + switch (dlist->polyType) + { + case 2: + writer->Write(dlist->x); + writer->Write(dlist->y); + writer->Write(dlist->z); + writer->Write(dlist->unk_06); + [[fallthrough]]; + default: + //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())); + } + else + writer->Write(""); + + 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())); + } + else + writer->Write(""); + break; + } +} diff --git a/OTRExporter/OTRExporter/RoomExporter.h b/OTRExporter/OTRExporter/RoomExporter.h new file mode 100644 index 000000000..f748658a5 --- /dev/null +++ b/OTRExporter/OTRExporter/RoomExporter.h @@ -0,0 +1,14 @@ +#pragma once + +#include "ZResource.h" +#include "Exporter.h" +#include "ZRoom/ZRoom.h" + +class PolygonDlist; + +class OTRExporter_Room : public OTRExporter +{ +public: + void WritePolyDList(BinaryWriter* writer, ZRoom* room, PolygonDlist* dlist); + virtual void Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer) override; +}; \ No newline at end of file diff --git a/OTRExporter/OTRExporter/SkeletonExporter.cpp b/OTRExporter/OTRExporter/SkeletonExporter.cpp new file mode 100644 index 000000000..cd9f7a8fd --- /dev/null +++ b/OTRExporter/OTRExporter/SkeletonExporter.cpp @@ -0,0 +1,39 @@ +#include "SkeletonExporter.h" +#include +#include +#include "DisplayListExporter.h" + +void OTRExporter_Skeleton::Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer) +{ + ZSkeleton* skel = (ZSkeleton*)res; + + WriteHeader(res, outPath, writer, Ship::ResourceType::Skeleton); + + writer->Write((uint8_t)skel->type); + writer->Write((uint8_t)skel->limbType); + + writer->Write((uint32_t)skel->limbCount); + writer->Write((uint32_t)skel->dListCount); + + writer->Write((uint8_t)skel->limbsTable.limbType); + writer->Write((uint32_t)skel->limbsTable.count); + + for (size_t i = 0; i < skel->limbsTable.count; i++) + { + 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); + if (foundDecl) + { + if (name.at(0) == '&') + name.erase(0, 1); + + writer->Write(OTRExporter_DisplayList::GetPathToRes(res, name)); + } + else + { + writer->Write(""); + } + } +} diff --git a/OTRExporter/OTRExporter/SkeletonExporter.h b/OTRExporter/OTRExporter/SkeletonExporter.h new file mode 100644 index 000000000..36ffcf269 --- /dev/null +++ b/OTRExporter/OTRExporter/SkeletonExporter.h @@ -0,0 +1,14 @@ +#pragma once + +#include "ZResource.h" +#include "ZTexture.h" +#include "ZDisplayList.h" +#include "ZSkeleton.h" +#include "Exporter.h" +#include + +class OTRExporter_Skeleton : public OTRExporter +{ +public: + virtual void Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer) override; +}; \ No newline at end of file diff --git a/OTRExporter/OTRExporter/SkeletonLimbExporter.cpp b/OTRExporter/OTRExporter/SkeletonLimbExporter.cpp new file mode 100644 index 000000000..d22c3d000 --- /dev/null +++ b/OTRExporter/OTRExporter/SkeletonLimbExporter.cpp @@ -0,0 +1,176 @@ +#include "SkeletonLimbExporter.h" +#include "DisplayListExporter.h" +#include +#include + +void OTRExporter_SkeletonLimb::Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer) +{ + ZLimb* limb = (ZLimb*)res; + + WriteHeader(res, outPath, writer, Ship::ResourceType::SkeletonLimb); + + writer->Write((uint8_t)limb->type); + writer->Write((uint8_t)limb->skinSegmentType); + + if (limb->skinSegmentType == ZLimbSkinType::SkinType_DList && limb->type == ZLimbType::Skin) + { + auto childDecl = limb->parent->GetDeclaration(GETSEGOFFSET(limb->skinSegment)); + + if (childDecl != nullptr) + writer->Write(OTRExporter_DisplayList::GetPathToRes(limb, childDecl->varName)); + else + writer->Write(""); + } + else + { + writer->Write(""); + } + + writer->Write((uint16_t)limb->segmentStruct.unk_0); + writer->Write((uint32_t)limb->segmentStruct.unk_4_arr.size()); + + for (auto item : limb->segmentStruct.unk_4_arr) + { + writer->Write(item.unk_4); + + writer->Write((uint32_t)item.unk_8_arr.size()); + + for (auto item2 : item.unk_8_arr) + { + writer->Write(item2.unk_0); + writer->Write(item2.unk_2); + writer->Write(item2.unk_4); + writer->Write(item2.unk_6); + writer->Write(item2.unk_7); + writer->Write(item2.unk_8); + writer->Write(item2.unk_9); + } + + writer->Write((uint32_t)item.unk_C_arr.size()); + + for (auto item2 : item.unk_C_arr) + { + writer->Write(item2.unk_0); + writer->Write(item2.x); + writer->Write(item2.y); + writer->Write(item2.z); + writer->Write(item2.unk_8); + } + } + + if (limb->segmentStruct.unk_8 != 0) + { + auto skinGfxDecl = limb->parent->GetDeclaration(GETSEGOFFSET(limb->segmentStruct.unk_8)); + + if (skinGfxDecl != nullptr) + { + writer->Write(OTRExporter_DisplayList::GetPathToRes(limb, skinGfxDecl->varName)); + } + else + { + writer->Write(""); + } + } + else + { + writer->Write(""); + } + + writer->Write(limb->legTransX); + writer->Write(limb->legTransY); + writer->Write(limb->legTransZ); + writer->Write(limb->rotX); + writer->Write(limb->rotY); + writer->Write(limb->rotZ); + + if (limb->childPtr != 0) + { + std::string name; + bool foundDecl = Globals::Instance->GetSegmentedPtrName(limb->childPtr, limb->parent, "", name); + if (foundDecl) + { + if (name.at(0) == '&') + name.erase(0, 1); + + writer->Write(OTRExporter_DisplayList::GetPathToRes(limb, name)); + } + else + { + writer->Write(""); + } + } + else + { + writer->Write(""); + } + + if (limb->siblingPtr != 0) + { + std::string name; + bool foundDecl = Globals::Instance->GetSegmentedPtrName(limb->siblingPtr, limb->parent, "", name); + if (foundDecl) + { + if (name.at(0) == '&') + name.erase(0, 1); + + writer->Write(OTRExporter_DisplayList::GetPathToRes(limb, name)); + } + else + { + writer->Write(""); + } + } + else + { + writer->Write(""); + } + + if (limb->dListPtr != 0) + { + std::string name; + bool foundDecl = Globals::Instance->GetSegmentedPtrName(limb->dListPtr, limb->parent, "", name); + if (foundDecl) + { + if (name.at(0) == '&') + name.erase(0, 1); + + writer->Write(OTRExporter_DisplayList::GetPathToRes(limb, name)); + } + else + { + writer->Write(""); + } + } + else + { + writer->Write(""); + } + + if (limb->dList2Ptr != 0) + { + std::string name; + bool foundDecl = Globals::Instance->GetSegmentedPtrName(limb->dList2Ptr, limb->parent, "", name); + if (foundDecl) + { + if (name.at(0) == '&') + name.erase(0, 1); + + writer->Write(OTRExporter_DisplayList::GetPathToRes(limb, name)); + } + else + { + writer->Write(""); + } + } + else + { + writer->Write(""); + } + + writer->Write(limb->transX); + writer->Write(limb->transY); + writer->Write(limb->transZ); + + writer->Write(limb->childIndex); + writer->Write(limb->siblingIndex); +} \ No newline at end of file diff --git a/OTRExporter/OTRExporter/SkeletonLimbExporter.h b/OTRExporter/OTRExporter/SkeletonLimbExporter.h new file mode 100644 index 000000000..000827443 --- /dev/null +++ b/OTRExporter/OTRExporter/SkeletonLimbExporter.h @@ -0,0 +1,15 @@ +#pragma once + +#include "ZResource.h" +#include "ZTexture.h" +#include "ZDisplayList.h" +#include "ZSkeleton.h" +#include "ZLimb.h" +#include "Exporter.h" +#include + +class OTRExporter_SkeletonLimb : public OTRExporter +{ +public: + virtual void Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer) override; +}; \ No newline at end of file diff --git a/OTRExporter/OTRExporter/TextExporter.cpp b/OTRExporter/OTRExporter/TextExporter.cpp new file mode 100644 index 000000000..19bc0ced1 --- /dev/null +++ b/OTRExporter/OTRExporter/TextExporter.cpp @@ -0,0 +1,19 @@ +#include "TextExporter.h" +#include "../ZAPD/ZFile.h" + +void OTRExporter_Text::Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer) +{ + ZText* txt = (ZText*)res; + + WriteHeader(txt, outPath, writer, Ship::ResourceType::Text); + + writer->Write((uint32_t)txt->messages.size()); + + for (int i = 0; i < txt->messages.size(); i++) + { + writer->Write(txt->messages[i].id); + writer->Write(txt->messages[i].textboxType); + writer->Write(txt->messages[i].textboxYPos); + writer->Write(txt->messages[i].msg); + } +} diff --git a/OTRExporter/OTRExporter/TextExporter.h b/OTRExporter/OTRExporter/TextExporter.h new file mode 100644 index 000000000..2eaf2ce71 --- /dev/null +++ b/OTRExporter/OTRExporter/TextExporter.h @@ -0,0 +1,12 @@ +#pragma once + +#include "ZResource.h" +#include "ZText.h" +#include "Exporter.h" +#include + +class OTRExporter_Text : public OTRExporter +{ +public: + virtual void Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer) override; +}; \ No newline at end of file diff --git a/OTRExporter/OTRExporter/TextureExporter.cpp b/OTRExporter/OTRExporter/TextureExporter.cpp new file mode 100644 index 000000000..69d00b6f3 --- /dev/null +++ b/OTRExporter/OTRExporter/TextureExporter.cpp @@ -0,0 +1,31 @@ +#include "TextureExporter.h" +#include "../ZAPD/ZFile.h" + +void OTRExporter_Texture::Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer) +{ + ZTexture* tex = (ZTexture*)res; + + WriteHeader(tex, outPath, writer, Ship::ResourceType::Texture); + + auto start = std::chrono::steady_clock::now(); + + //printf("Exporting Texture %s\n", tex->GetName().c_str()); + + writer->Write((uint32_t)tex->GetTextureType()); + writer->Write((uint32_t)tex->GetWidth()); + writer->Write((uint32_t)tex->GetHeight()); + + writer->Write((uint32_t)tex->GetRawDataSize()); + + auto data = tex->parent->GetRawData(); + + writer->Write((char*)data.data() + tex->GetRawDataIndex(), tex->GetRawDataSize()); + + auto end = std::chrono::steady_clock::now(); + size_t diff = std::chrono::duration_cast(end - start).count(); + + //printf("Exported Texture %s in %zums\n", tex->GetName().c_str(), diff); + + //if (diff > 2) + //printf("Export took %lms\n", diff); +} \ No newline at end of file diff --git a/OTRExporter/OTRExporter/TextureExporter.h b/OTRExporter/OTRExporter/TextureExporter.h new file mode 100644 index 000000000..cdf7491a8 --- /dev/null +++ b/OTRExporter/OTRExporter/TextureExporter.h @@ -0,0 +1,12 @@ +#pragma once + +#include "ZResource.h" +#include "ZTexture.h" +#include "Exporter.h" +#include + +class OTRExporter_Texture : public OTRExporter +{ +public: + virtual void Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer) override; +}; \ No newline at end of file diff --git a/OTRExporter/OTRExporter/VersionInfo.cpp b/OTRExporter/OTRExporter/VersionInfo.cpp new file mode 100644 index 000000000..9b684d22b --- /dev/null +++ b/OTRExporter/OTRExporter/VersionInfo.cpp @@ -0,0 +1,25 @@ +#include "VersionInfo.h" +#include + +std::map 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; +} \ No newline at end of file diff --git a/OTRExporter/OTRExporter/VersionInfo.h b/OTRExporter/OTRExporter/VersionInfo.h new file mode 100644 index 000000000..6c380a6b5 --- /dev/null +++ b/OTRExporter/OTRExporter/VersionInfo.h @@ -0,0 +1,9 @@ +#pragma once + +#include +#include +#include "Resource.h" + +#define MAJOR_VERSION Ship::Version::Deckard + +extern std::map resourceVersions; \ No newline at end of file diff --git a/OTRExporter/OTRExporter/VtxExporter.cpp b/OTRExporter/OTRExporter/VtxExporter.cpp new file mode 100644 index 000000000..10a13f424 --- /dev/null +++ b/OTRExporter/OTRExporter/VtxExporter.cpp @@ -0,0 +1,44 @@ +#include "VtxExporter.h" +#include "Resource.h" +#include "VersionInfo.h" + + +void OTRExporter_Vtx::SaveArr(ZResource* res, const fs::path& outPath, const std::vector& vec, BinaryWriter* writer) +{ + WriteHeader(res, outPath, writer, Ship::ResourceType::Vertex); + + for (auto& res: vec) { + ZVtx* vtx = (ZVtx*)res; + writer->Write(vtx->x); + writer->Write(vtx->y); + writer->Write(vtx->z); + writer->Write(vtx->flag); + writer->Write(vtx->s); + writer->Write(vtx->t); + writer->Write(vtx->r); + writer->Write(vtx->g); + writer->Write(vtx->b); + writer->Write(vtx->a); + } + +} + +void OTRExporter_Vtx::Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer) +{ + ZVtx* vtx = (ZVtx*)res; + + WriteHeader(res, outPath, writer, Ship::ResourceType::Vertex); + + writer->Write((uint32_t)1); //Yes I'm hard coding it to one, it *should* be fine. + + writer->Write(vtx->x); + writer->Write(vtx->y); + writer->Write(vtx->z); + writer->Write(vtx->flag); + writer->Write(vtx->s); + writer->Write(vtx->t); + writer->Write(vtx->r); + writer->Write(vtx->g); + writer->Write(vtx->b); + writer->Write(vtx->a); +} diff --git a/OTRExporter/OTRExporter/VtxExporter.h b/OTRExporter/OTRExporter/VtxExporter.h new file mode 100644 index 000000000..433aadd2c --- /dev/null +++ b/OTRExporter/OTRExporter/VtxExporter.h @@ -0,0 +1,13 @@ +#pragma once + +#include "ZResource.h" +#include "ZVtx.h" +#include "Exporter.h" +#include + +class OTRExporter_Vtx : public OTRExporter +{ +public: + void SaveArr(ZResource* res, const fs::path& outPath, const std::vector&, BinaryWriter* writer); + virtual void Save(ZResource* res, const fs::path& outPath, BinaryWriter* writer) override; +}; \ No newline at end of file diff --git a/OTRExporter/OTRExporter/command_macros_base.h b/OTRExporter/OTRExporter/command_macros_base.h new file mode 100644 index 000000000..3067d2ce1 --- /dev/null +++ b/OTRExporter/OTRExporter/command_macros_base.h @@ -0,0 +1,36 @@ +#ifndef COMMAND_MACROS_BASE_H +#define COMMAND_MACROS_BASE_H + +/** + * Command Base macros intended for use in designing of more specific command macros + * Each macro packs bytes (B), halfwords (H) and words (W, for consistency) into a single word + */ + +#define _SHIFTL(v, s, w) \ + ((unsigned int) (((unsigned int)(v) & ((0x01 << (w)) - 1)) << (s))) +#define _SHIFTR(v, s, w) \ + ((unsigned int)(((unsigned int)(v) >> (s)) & ((0x01 << (w)) - 1))) + +//#define CMD_BBBB(a, b, c, d) (_SHIFTL(a, 24, 8) | _SHIFTL(b, 16, 8) | _SHIFTL(c, 8, 8) | _SHIFTL(d, 0, 8)) +#define CMD_BBBB(a, b, c, d) (_SHIFTL(d, 24, 8) | _SHIFTL(c, 16, 8) | _SHIFTL(b, 8, 8) | _SHIFTL(a, 0, 8)) + +//#define CMD_BBH(a, b, c) (_SHIFTL(a, 24, 8) | _SHIFTL(b, 16, 8) | _SHIFTL(c, 0, 16)) +#define CMD_BBH(a, b, c) (_SHIFTL(a, 0, 8) | _SHIFTL(b, 8, 8) | _SHIFTL(c, 16, 16)) + +//#define CMD_HBB(a, b, c) (_SHIFTL(a, 16, 16) | _SHIFTL(b, 8, 8) | _SHIFTL(c, 0, 8)) +#define CMD_HBB(a, b, c) (_SHIFTL(c, 24, 8) | _SHIFTL(b, 16, 8) | _SHIFTL(a, 0, 16)) + +//#define CMD_HH(a, b) (_SHIFTL(a, 16, 16) | _SHIFTL(b, 0, 16)) +#define CMD_HH(a, b) (_SHIFTL(b, 16, 16) | _SHIFTL(a, 0, 16)) + +#define CMD_W(a) (a) + +#if defined(__GNUC__) +#define CMD_F(a) {.f = (a)} +#else +#define CMD_F(a) {(a)} +#endif + +#define CMD_PTR(a) (u32)(a) + +#endif \ No newline at end of file diff --git a/OTRExporter/OTRExporter/z64cutscene.h b/OTRExporter/OTRExporter/z64cutscene.h new file mode 100644 index 000000000..4f44c1025 --- /dev/null +++ b/OTRExporter/OTRExporter/z64cutscene.h @@ -0,0 +1,290 @@ +#ifndef Z64CUTSCENE_H +#define Z64CUTSCENE_H + +#if 0 +#include "ultra64.h" + +typedef struct { + /* 0x00 */ u16 entrance; // entrance index upon which the cutscene should trigger + /* 0x02 */ u8 ageRestriction; // 0 for adult only, 1 for child only, 2 for both ages + /* 0x03 */ u8 flag; // eventChkInf flag bound to the entrance cutscene + /* 0x04 */ void* segAddr; // segment offset location of the cutscene +} EntranceCutscene; // size = 0x8 + +typedef struct { + /* 0x00 */ s8 continueFlag; + /* 0x01 */ s8 cameraRoll; + /* 0x02 */ u16 nextPointFrame; + /* 0x04 */ f32 viewAngle; // in degrees + /* 0x08 */ Vec3s pos; +} CutsceneCameraPoint; // size = 0x10 + +typedef struct { + /* 0x00 */ Vec3f at; + /* 0x0C */ Vec3f eye; + /* 0x18 */ s16 roll; + /* 0x1A */ s16 fov; +} CutsceneCameraAngle; // size = 0x1C + +typedef struct { + /* 0x0 */ CutsceneCameraPoint* atPoints; + /* 0x4 */ CutsceneCameraPoint* eyePoints; + /* 0x8 */ s16 relativeToPlayer; +} CutsceneCameraMove; // size = 0xC + +typedef struct { + /* 0x00 */ u16 base; + /* 0x02 */ u16 startFrame; + /* 0x04 */ u16 endFrame; +} CsCmdBase; // size = 0x6 + +typedef struct { + /* 0x00 */ u8 unk_00; + /* 0x01 */ u8 setting; + /* 0x02 */ u16 startFrame; + /* 0x04 */ u16 endFrame; +} CsCmdEnvLighting; // size = 0x6 + +typedef struct { + /* 0x00 */ u8 unk_00; + /* 0x01 */ u8 sequence; + /* 0x02 */ u16 startFrame; + /* 0x04 */ u16 endFrame; +} CsCmdMusicChange; // size = 0x6 + +typedef struct { + /* 0x00 */ u16 type; + /* 0x02 */ u16 startFrame; + /* 0x04 */ u16 endFrame; +} CsCmdMusicFade; // size = 0x6 + +typedef struct { + /* 0x00 */ u16 unk_00; + /* 0x02 */ u16 startFrame; + /* 0x04 */ u16 endFrame; + /* 0x06 */ u8 unk_06; + /* 0x07 */ u8 unk_07; + /* 0x08 */ u8 unk_08; +} CsCmdUnknown9; // size = 0xA + +typedef struct { + /* 0x00 */ u16 unk_00; + /* 0x02 */ u16 startFrame; + /* 0x04 */ u16 endFrame; + /* 0x06 */ u8 hour; + /* 0x07 */ u8 minute; +} CsCmdDayTime; // size = 0x8 + +typedef struct { + /* 0x00 */ u16 base; + /* 0x02 */ u16 startFrame; + /* 0x04 */ u16 endFrame; + /* 0x06 */ u16 type; + /* 0x08 */ u16 textId1; + /* 0x0A */ u16 textId2; +} CsCmdTextbox; // size = 0xC + +typedef struct { + /* 0x00 */ u16 action; // "dousa" + /* 0x02 */ u16 startFrame; + /* 0x04 */ u16 endFrame; + union { + /* 0x06 */ Vec3s rot; + /* 0x06 */ Vec3us urot; + }; + /* 0x0C */ Vec3i startPos; + /* 0x18 */ Vec3i endPos; + /* 0x24 */ Vec3i normal; +} CsCmdActorAction; // size = 0x30 +#endif + +typedef enum { + CS_STATE_IDLE, + CS_STATE_SKIPPABLE_INIT, + CS_STATE_SKIPPABLE_EXEC, + CS_STATE_UNSKIPPABLE_INIT, + CS_STATE_UNSKIPPABLE_EXEC +} CutsceneState; + +typedef enum { + CS_CMD_00 = 0x0000, + CS_CMD_CAM_EYE = 0x0001, + CS_CMD_CAM_AT = 0x0002, + CS_CMD_MISC = 0x0003, + CS_CMD_SET_LIGHTING = 0x0004, + CS_CMD_CAM_EYE_REL_TO_PLAYER = 0x0005, + CS_CMD_CAM_AT_REL_TO_PLAYER = 0x0006, + CS_CMD_07 = 0x0007, + CS_CMD_08 = 0x0008, + CS_CMD_09 = 0x0009, + CS_CMD_TEXTBOX = 0x0013, + CS_CMD_SET_PLAYER_ACTION = 0x000A, + CS_CMD_SET_ACTOR_ACTION_1 = 0x000F, + CS_CMD_SET_ACTOR_ACTION_2 = 0x000E, + CS_CMD_SET_ACTOR_ACTION_3 = 0x0019, + CS_CMD_SET_ACTOR_ACTION_4 = 0x001D, + CS_CMD_SET_ACTOR_ACTION_5 = 0x001E, + CS_CMD_SET_ACTOR_ACTION_6 = 0x002C, + CS_CMD_SET_ACTOR_ACTION_7 = 0x001F, + CS_CMD_SET_ACTOR_ACTION_8 = 0x0031, + CS_CMD_SET_ACTOR_ACTION_9 = 0x003E, + CS_CMD_SET_ACTOR_ACTION_10 = 0x008F, + CS_CMD_SCENE_TRANS_FX = 0x002D, + CS_CMD_NOP = 0x000B, + CS_CMD_PLAYBGM = 0x0056, + CS_CMD_STOPBGM = 0x0057, + CS_CMD_FADEBGM = 0x007C, + CS_CMD_SETTIME = 0x008C, + CS_CMD_TERMINATOR = 0x03E8, + CS_CMD_END = 0xFFFF +} CutsceneCmd; + +/** + * Special type for blocks of cutscene data, asm-processor checks + * arrays for CutsceneData type and converts floats within the array + * to their IEEE-754 representation. The array must close with }; + * on its own line. + * + * Files that contain this type that are included in other C files + * must include an 'EARLY' qualifier to inform asm-processor that it + * must recursively process that include. + * + * Example: #include "file.c" EARLY + */ + + +typedef union CutsceneData { + int i; + float f; + short s[2]; + char b[4]; +} CutsceneData; + +#define CS_CMD_CONTINUE 0 +#define CS_CMD_STOP -1 + +// TODO confirm correctness, clarify names +typedef enum { + /* 0x00 */ INVALID_DESTINATION_0, + /* 0x01 */ CUTSCENE_MAP_GANON_HORSE, + /* 0x02 */ CUTSCENE_MAP_THREE_GODESSES_POST_DEKU_TREE, + /* 0x03 */ GERUDO_VALLEY_DIN, + /* 0x04 */ DEATH_MOUNTAIN_TRAIL_NAYRU, + /* 0x05 */ KOKIRI_FOREST_FARORE, + /* 0x06 */ CUTSCENE_MAP_TRIFORCE_CREATION, + /* 0x07 */ KOKIRI_FOREST_RECEIVE_KOKIRI_EMERALD, + /* 0x08 */ TEMPLE_OF_TIME_AFTER_USE_MS, + /* 0x09 */ GERUDO_VALLEY_DIN_2, + /* 0x0A */ LINKS_HOUSE_INTRO, + /* 0x0B */ KOKIRI_FOREST_INTRO, + /* 0x0C */ DEATH_MOUNTAIN_TRAIL_AFTER_GORON_RUBY, + /* 0x0D */ ZORAS_FOUNTAIN_AFTER_ZORAS_SAPPHIRE, + /* 0x0E */ KOKIRI_FOREST_AFTER_KOKIRI_EMERALD, + /* 0x0F */ TEMPLE_OF_TIME_KOKIRI_EMERALD, //unused + /* 0x10 */ TEMPLE_OF_TIME_GORON_RUBY, //unused + /* 0x11 */ TEMPLE_OF_TIME_ZORAS_SAPPHIRE, //unused + /* 0x12 */ TEMPLE_OF_TIME_AFTER_USE_MS_FIRST, + /* 0x13 */ DEATH_MOUNTAIN_TRAIL_AFTER_INTRO, + /* 0x14 */ INVALID_DESTINATION_14, + /* 0x15 */ LAKE_HYLIA_WATER_RISES, + /* 0x16 */ DESERT_COLOSSUS_REQUIEM, + /* 0x17 */ CUTSCENE_MAP_CURSE_YOU, + /* 0x18 */ JABU_JABU_INTRO, + /* 0x19 */ CHAMBER_OF_SAGES_LIGHT_MEDALLION, + /* 0x1A */ TEMPLE_OF_TIME_KOKIRI_EMERALD_2, //duplicate of 0x000F + /* 0x1B */ TEMPLE_OF_TIME_GORON_RUBY_2, //duplicate of 0x0010 + /* 0x1C */ TEMPLE_OF_TIME_ZORAS_SAPPHIRE_2, //duplicate of 0x0011 + /* 0x1D */ CHAMBER_OF_SAGES_FOREST_MEDALLION, + /* 0x1E */ CHAMBER_OF_SAGES_FIRE_MEDALLION, + /* 0x1F */ CHAMBER_OF_SAGES_WATER_MEDALLION, + /* 0x20 */ HYRULE_FIELD_FLASHBACK, //lacs part 4 + /* 0x21 */ HYRULE_FIELD_AFTER_LAKE_HYLIA_OWL, + /* 0x22 */ CUTSCENE_MAP_GANON_AFTER_USE_MS, + /* 0x23 */ HYRULE_FIELD_INTRO_ZELDA_ESCAPE, + /* 0x24 */ INVALID_DESTINATION_24, + /* 0x25 */ INVALID_DESTINATION_25, + /* 0x26 */ CUTSCENE_MAP_SHEIKAH_LEGEND, //lacs part 2 + /* 0x27 */ TEMPLE_OF_TIME_ZELDA_REVEAL, //lacs part 3 + /* 0x28 */ TEMPLE_OF_TIME_GET_LIGHT_ARROWS, //lacs part 5 + /* 0x29 */ LAKE_HYLIA_AFTER_BLUE_WARP, + /* 0x2A */ KAKARIKO_VILLAGE_DRAIN_WELL, + /* 0x2B */ WINDMILL_AFTER_DRAIN_WELL, + /* 0x2C */ TEMPLE_OF_TIME_AFTER_DOOR_OF_TIME_OPENS, + /* 0x2D */ INVALID_DESTINATION_2D, + /* 0x2E */ TEMPLE_OF_TIME_AFTER_USE_MS_FIRST_2, // duplicate of 0x0012 + /* 0x2F */ KAKARIKO_VILLAGE_NOCTURNE_PART_2, + /* 0x30 */ DESERT_COLOSSUS_AFTER_REQUIEM, + /* 0x31 */ TEMPLE_OF_TIME_AFTER_LIGHT_ARROWS, + /* 0x32 */ KAKARIKO_VILLAGE_AFTER_NOCTURNE, + /* 0x33 */ HYRULE_FIELD_IMPA_ESCORT_CS, + /* 0x34 */ TEMPLE_OF_TIME_SONG_OF_TIME, + /* 0x35 */ HYRULE_FIELD_AFTER_SONG_OF_TIME, + /* 0x36 */ GERUDO_VALLEY_CREDITS, + /* 0x37 */ GERUDO_FORTRESS_CREDITS, + /* 0x38 */ KAKARIKO_VILLAGE_CREDITS, + /* 0x39 */ DEATH_MOUNTAIN_TRAIL_CREDITS_1, + /* 0x3A */ GORON_CITY_CREDITS, // unused? + /* 0x3B */ LAKE_HYLIA_CREDITS, + /* 0x3C */ ZORAS_FOUNTAIN_CREDITS, // unused + /* 0x3D */ ZORAS_DOMAIN_CREDITS, + /* 0x3E */ KOKIRI_FOREST_CREDITS_1, + /* 0x3F */ KOKIRI_FOREST_CREDITS_2, + /* 0x40 */ HYRULE_FIELD_CREDITS, + /* 0x41 */ LON_LON_RANCH_CREDITS_1, + /* 0x42 */ KAKARIKO_VILLAGE_AFTER_TRAIL_OWL, + /* 0x43 */ HTRULE_FIELD_UNUSED_ENTRANCE, + /* 0x44 */ CUTSCENE_MAP_FIRE, + /* 0x45 */ KOKIRI_FOREST_POST_FOREST_MEDALLION, + /* 0x46 */ DEATH_MOUNTAIN_TRAIL_CREDITS_2, + /* 0x47 */ TEMPLE_OF_TIME_CREDITS, + /* 0x48 */ ZELDAS_COURTYARD_CREDITS, + /* 0x49 */ LON_LON_RANCH_CREDITS_1_2, // duplicate of 0x0041 + /* 0x4A */ LON_LON_RANCH_CREDITS_2, + /* 0x4B */ LON_LON_RANCH_CREDITS_3, + /* 0x4C */ LON_LON_RANCH_CREDITS_4, + /* 0x4D */ LON_LON_RANCH_CREDITS_5, + /* 0x4E */ LON_LON_RANCH_CREDITS_6, + /* 0x4F */ LON_LON_RANCH_NO_CS_1, + /* 0x50 */ LON_LON_RANCH_NO_CS_2, + /* 0x51 */ LON_LON_RANCH_NO_CS_3, + /* 0x52 */ LON_LON_RANCH_NO_CS_4, + /* 0x53 */ LON_LON_RANCH_NO_CS_5, + /* 0x54 */ LON_LON_RANCH_NO_CS_6, + /* 0x55 */ LON_LON_RANCH_NO_CS_7, + /* 0x56 */ LON_LON_RANCH_NO_CS_8, + /* 0x57 */ LON_LON_RANCH_NO_CS_9, + /* 0x58 */ LON_LON_RANCH_NO_CS_10, + /* 0x59 */ LON_LON_RANCH_NO_CS_11, + /* 0x5A */ LON_LON_RANCH_NO_CS_12, + /* 0x5B */ LON_LON_RANCH_NO_CS_13, + /* 0x5C */ LON_LON_RANCH_NO_CS_14, + /* 0x5D */ LON_LON_RANCH_NO_CS_15, + /* 0x5E */ LON_LON_RANCH_NO_CS_EPONAS_SONG, + /* 0x5F */ CONDITIONAL_DESTINATION, // TODO more descriptive name? + /* 0x60 */ DESERT_COLOSSUS_SPIRIT_BLUE_WARP, + /* 0x61 */ GRAVEYARD_AFTER_SHADOW_BLUE_WARP, + /* 0x62 */ DEATH_MOUNTAIN_CRATER_AFTER_FIRE_BLUE_WARP, + /* 0x63 */ SACRED_FOREST_MEADOW_AFTER_FOREST_BLUE_WARP, + /* 0x64 */ KOKIRI_FOREST_AFTER_FOREST_BLUE_WARP, + /* 0x65 */ DESERT_COLOSSUS_AFTER_SILVER_GAUNTLETS, + /* 0x66 */ TEMPLE_OF_TIME_FRONT_OF_PEDESTAL, + /* 0x67 */ HYRULE_FIELD_TITLE_SCREEN, + /* 0x68 */ SPIRIT_TEMPLE_BOSS_TITLE_SCREEN, + /* 0x69 */ GRAVEYARD_SUNS_SONG, + /* 0x6A */ ROYAL_FAMILYS_TOMB_SUNS_SONG, + /* 0x6B */ GANONS_CASTLE_AFTER_FOREST_TRIAL, + /* 0x6C */ GANONS_CASTLE_AFTER_WATER_TRIAL, + /* 0x6D */ GANONS_CASTLE_AFTER_SHADOW_TRIAL, + /* 0x6E */ GANONS_CASTLE_AFTER_FIRE_TRIAL, + /* 0x6F */ GANONS_CASTLE_AFTER_LIGHT_TRIAL, + /* 0x70 */ GANONS_CASTLE_AFTER_SPIRIT_TRIAL, + /* 0x71 */ GANONS_CASTLE_DISPEL_BARRIER_IF_CONDITIONS, + /* 0x72 */ HYRULE_FIELD_INTRO, + /* 0x73 */ HYRULE_FIELD_AFTER_IMPA_ESCORT, + /* 0x74 */ DESERT_COLOSSUS_SPIRIT_BLUE_WARP_2, + /* 0x75 */ HYRULE_FIELD_SKY, + /* 0x76 */ GANON_BATTLE_TOWER_COLLAPSE, + /* 0x77 */ ZELDAS_COURTYARD_RECEIVE_LETTER +} CutsceneTerminatorDestination; + +#endif \ No newline at end of file diff --git a/OTRExporter/OTRExporter/z64cutscene_commands.h b/OTRExporter/OTRExporter/z64cutscene_commands.h new file mode 100644 index 000000000..5d440cce9 --- /dev/null +++ b/OTRExporter/OTRExporter/z64cutscene_commands.h @@ -0,0 +1,448 @@ +#ifndef Z64CUTSCENE_COMMANDS_H +#define Z64CUTSCENE_COMMANDS_H + +#include "command_macros_base.h" +#include "z64cutscene.h" + +/** + * ARGS + * s32 totalEntries (e), s32 endFrame (n) + * FORMAT + * eeeeeeee nnnnnnnn + * size = 0x8 + */ +#define CS_BEGIN_CUTSCENE(totalEntries, endFrame) CMD_W(totalEntries), CMD_W(endFrame) + + /** + * ARGS + * s16 startFrame (s), s16 endFrame (e) + * FORMAT + * 00000001 0001ssss eeee0000 + * size = 0xC + */ +#define CS_CAM_POS_LIST CS_CAM_EYE_LIST +#define CS_CAM_EYE_LIST(startFrame, endFrame) \ + CS_CMD_CAM_EYE, CMD_HH(0x0001, startFrame), CMD_HH(endFrame, 0x0000) + + /** + * ARGS + * s8 continueFlag (c), s8 roll (r), s16 frame (f), f32 viewAngle (a), + * s16 xPos (x), s16 yPos (y), s16 zPos (z) + * FORMAT + * Capital U is Unused + * ccrrffff aaaaaaaa xxxxyyyy zzzzUUUU + * size = 0x10 + */ +#define CS_CAM_POS CS_CAM_EYE +#define CS_CAM_EYE(continueFlag, roll, frame, viewAngle, xPos, yPos, zPos, unused) \ + CMD_BBH(continueFlag, roll, frame), CMD_F(viewAngle), CMD_HH(xPos, yPos), CMD_HH(zPos, unused) + + /** + * ARGS + * s16 startFrame (s), s16 endFrame (e) + * FORMAT + * 00000002 0001ssss eeee0000 + * size = 0xC + */ +#define CS_CAM_FOCUS_POINT_LIST CS_CAM_AT_LIST +#define CS_CAM_AT_LIST(startFrame, endFrame) \ + CS_CMD_CAM_AT, CMD_HH(0x0001, startFrame), CMD_HH(endFrame, 0x0000) + + /** + * ARGS + * s8 continueFlag (c), s8 roll (r), s16 frame (f), f32 viewAngle (a), + * s16 xPos (x), s16 yPos (y), s16 zPos (z) + * FORMAT + * Capital U is Unused + * ccrrffff aaaaaaaa xxxxyyyy zzzzUUUU + * size = 0x10 + */ +#define CS_CAM_FOCUS_POINT CS_CAM_AT +#define CS_CAM_AT(continueFlag, roll, frame, viewAngle, xPos, yPos, zPos, unused) \ + CMD_BBH(continueFlag, roll, frame), CMD_F(viewAngle), CMD_HH(xPos, yPos), CMD_HH(zPos, unused) + + /** + * ARGS + * s32 entries (e) + * FORMAT + * 00000003 eeeeeeee + * size = 0x8 + */ +#define CS_MISC_LIST(entries) CS_CMD_MISC, CMD_W(entries) + + /** + * ARGS + * s16 unk (u), s16 startFrame (s), s16 endFrame (e) + * FORMAT + * Capital U is Unused + * uuuussss eeeeUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU + * size = 0x30 + */ +#define CS_MISC(unk, startFrame, endFrame, unused0, unused1, unused2, unused3, unused4, unused5, unused6, unused7, unused8, unused9, unused10) \ + CMD_HH(unk, startFrame), CMD_HH(endFrame, unused0), \ + CMD_W(unused1), CMD_W(unused2), CMD_W(unused3), CMD_W(unused4), CMD_W(unused5), \ + CMD_W(unused6), CMD_W(unused7), CMD_W(unused8), CMD_W(unused9), CMD_W(unused10) + + /** + * ARGS + * s32 entries (e) + * FORMAT + * 00000004 eeeeeeee + * size = 0x8 + */ +#define CS_LIGHTING_LIST(entries) CS_CMD_SET_LIGHTING, CMD_W(entries) + + /** + * ARGS + * s16 setting (m), s16 startFrame (s), s16 endFrame (e) + * FORMAT + * Capital U is Unused + * mmmmssss eeeeUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU 00000000 00000000 00000000 + * size = 0x30 + */ +#define CS_LIGHTING(setting, startFrame, endFrame, unused0, unused1, unused2, unused3, unused4, unused5, unused6, unused7) \ + CMD_HH(setting, startFrame), CMD_HH(endFrame, unused0), \ + CMD_W(unused1), CMD_W(unused2), CMD_W(unused3), CMD_W(unused4), CMD_W(unused5), \ + CMD_W(unused6), CMD_W(unused7), 0x00000000, 0x00000000, 0x00000000 + + /** + * ARGS + * s16 startFrame (s), s16 endFrame (e) + * FORMAT + * Capital U is Unused , may be consistently zero + * 00000005 0001ssss eeee0000 + * size = 0xC + */ +#define CS_CAM_POS_PLAYER_LIST CS_CAM_EYE_REL_TO_PLAYER_LIST +#define CS_CAM_EYE_REL_TO_PLAYER_LIST(startFrame, endFrame) \ + CS_CMD_CAM_EYE_REL_TO_PLAYER, CMD_HH(0x0001, startFrame), CMD_HH(endFrame, 0x0000) + + /** + * ARGS + * s8 continueFlag (c), s8 roll (r), s16 frame (f), f32 viewAngle (a), + * s16 xPos (x), s16 yPos (y), s16 zPos (z) + * FORMAT + * Capital U is Unused + * ccrrffff aaaaaaaa xxxxyyyy zzzzUUUU + * size = 0x10 + */ +#define CS_CAM_POS_PLAYER CS_CAM_EYE_REL_TO_PLAYER +#define CS_CAM_EYE_REL_TO_PLAYER(continueFlag, roll, frame, viewAngle, xPos, yPos, zPos, unused) \ + CMD_BBH(continueFlag, roll, frame), CMD_F(viewAngle), CMD_HH(xPos, yPos), CMD_HH(zPos, unused) + + /** + * ARGS + * s16 startFrame (s), s16 endFrame (e) + * FORMAT + * Capital U is Unused , may be consistently zero + * 00000006 0001ssss eeee0000 + * size = 0xC + */ +#define CS_CAM_FOCUS_POINT_PLAYER_LIST CS_CAM_AT_REL_TO_PLAYER_LIST +#define CS_CAM_AT_REL_TO_PLAYER_LIST(startFrame, endFrame) \ + CS_CMD_CAM_AT_REL_TO_PLAYER, CMD_HH(0x0001, startFrame), CMD_HH(endFrame, 0x0000) + /** + * ARGS + * s8 continueFlag (c), s8 roll (r), s16 frame (f), f32 viewAngle (a), + * s16 xPos (x), s16 yPos (y), s16 zPos (z) + * FORMAT + * Capital U is Unused + * ccrrffff aaaaaaaa xxxxyyyy zzzzUUUU + * size = 0x10 + */ +#define CS_CAM_FOCUS_POINT_PLAYER CS_CAM_AT_REL_TO_PLAYER +#define CS_CAM_AT_REL_TO_PLAYER(continueFlag, roll, frame, viewAngle, xPos, yPos, zPos, unused) \ + CMD_BBH(continueFlag, roll, frame), CMD_F(viewAngle), CMD_HH(xPos, yPos), CMD_HH(zPos, unused) + + /** + * ARGS + * s16 unk (u), s16 startFrame (s), s16 endFrame (e) + * FORMAT + * Capital U is Unused + * 00000007 uuuussss eeeeUUUU + * size = 0xC + */ +#define CS_CMD_07_LIST(unk, startFrame, endFrame, unused) \ + CS_CMD_07, CMD_HH(unk, startFrame), CMD_HH(endFrame, unused) + + /** + * ARGS + * s8 continueFlag (c), s8 roll (r), s16 frame (f), f32 viewAngle (a), + * s16 xPos (x), s16 yPos (y), s16 zPos (z) + * FORMAT + * Capital U is Unused + * ccrrffff aaaaaaaa xxxxyyyy zzzzUUUU + * size = 0x10 + */ +#define CS_CMD_07(continueFlag, roll, frame, viewAngle, xPos, yPos, zPos, unused) \ + CMD_BBH(continueFlag, roll, frame), CMD_F(viewAngle), CMD_HH(xPos, yPos), CMD_HH(zPos, unused) + + /** + * ARGS + * s16 unk (u), s16 startFrame (s), s16 endFrame (e) + * FORMAT + * Capital U is Unused + * 00000008 uuuussss eeeeUUUU + * size = 0xC + */ +#define CS_CMD_08_LIST(unk, startFrame, endFrame, unused) \ + CS_CMD_08, CMD_HH(unk, startFrame), CMD_HH(endFrame, unused) + + /** + * ARGS + * s8 continueFlag (c), s8 roll (r), s16 frame (f), f32 viewAngle (a), + * s16 xPos (x), s16 yPos (y), s16 zPos (z) + * FORMAT + * Capital U is Unused + * ccrrffff aaaaaaaa xxxxyyyy zzzzUUUU + * size = 0x10 + */ +#define CS_CMD_08(continueFlag, roll, frame, viewAngle, xPos, yPos, zPos, unused) \ + CMD_BBH(continueFlag, roll, frame), CMD_F(viewAngle), CMD_HH(xPos, yPos), CMD_HH(zPos, unused) + + /** + * ARGS + * s32 entries (e) + * FORMAT + * 00000009 eeeeeeee + * size = 0x8 + */ +#define CS_CMD_09_LIST(entries) CS_CMD_09, CMD_W(entries) + + /** + * ARGS + * s16 unk (u), s16 startFrame (s), s16 endFrame (e), s16 unk2 (v), s16 unk3 (w), s16 unk4 (x) + * FORMAT + * Capital U is Unused + * uuuussss eeeevvww xxUUUUUU + * size = 0xC + */ +#define CS_CMD_09(unk, startFrame, endFrame, unk2, unk3, unk4, unused0, unused1) \ + CMD_HH(unk, startFrame), CMD_HBB(endFrame, unk2, unk3), CMD_BBH(unk4, unused0, unused1) + + /** + * ARGS + * s32 cmdType (c), s32 entries (e) + * FORMAT + * cccccccc eeeeeeee + * size = 0x8 + */ +#define CS_UNK_DATA_LIST(cmdType, entries) CMD_W(cmdType), CMD_W(entries) + + /** + * ARGS + * s32 unk1 (a), s32 unk2 (b), s32 unk3 (c), s32 unk4 (d), s32 unk5 (e), s32 unk6 (f), + * s32 unk7 (g), s32 unk8 (h), s32 unk9 (i), s32 unk10 (j), s32 unk11 (k), s32 unk12 (l) + * FORMAT + * aaaaaaaa bbbbbbbb cccccccc dddddddd eeeeeeee ffffffff gggggggg hhhhhhhh iiiiiiii jjjjjjjj kkkkkkkk llllllll + * size = 0x30 + */ +#define CS_UNK_DATA(unk1, unk2, unk3, unk4, unk5, unk6, unk7, unk8, unk9, unk10, unk11, unk12) \ + CMD_W(unk1), CMD_W(unk2), CMD_W(unk3), CMD_W(unk4), CMD_W(unk5), CMD_W(unk6), \ + CMD_W(unk7), CMD_W(unk8), CMD_W(unk9), CMD_W(unk10), CMD_W(unk11), CMD_W(unk12) + + /** + * ARGS + * s32 cmdType (c), s32 entries (e) + * FORMAT + * cccccccc eeeeeeee + * size = 0x8 + */ +#define CS_NPC_ACTION_LIST(cmdType, entries) CMD_W(cmdType), CMD_W(entries) + + /** + * ARGS + * s16 npcAction (a), s16 startFrame (s), s16 endFrame (e), + * s16 rotX (u), s16 rotY (v), s16 rotZ (w), + * s32 startX (i), s32 startY (j), s32 startZ (k), + * s32 endX (l), s32 endY (m), s32 endZ (n), + * f32 normX (x), f32 normY (y), f32 normZ (z), + * FORMAT + * aaaassss eeeeuuuu vvvvwwww iiiiiiii jjjjjjjj kkkkkkkk llllllll mmmmmmmm nnnnnnnn xxxxxxxx yyyyyyyy zzzzzzzz + * size = 0x30 + */ +#define CS_NPC_ACTION(npcAction, startFrame, endFrame, rotX, rotY, rotZ, startX, startY, startZ, endX, endY, endZ, normX, normY, normZ) \ + CMD_HH(npcAction, startFrame), CMD_HH(endFrame, rotX), CMD_HH(rotY, rotZ), \ + CMD_W(startX), CMD_W(startY), CMD_W(startZ), \ + CMD_W(endX), CMD_W(endY), CMD_W(endZ), \ + CMD_F(normX), CMD_F(normY), CMD_F(normZ) + + /** + * ARGS + * s32 cmdType (c), s32 entries (e) + * FORMAT + * cccccccc eeeeeeee + * size = 0x8 + */ +#define CS_PLAYER_ACTION_LIST(entries) CS_CMD_SET_PLAYER_ACTION, CMD_W(entries) + + /** + * ARGS + * s16 linkAction (a), s16 startFrame (s), s16 endFrame (e), + * s16 rotX (u), s16 rotY (v), s16 rotZ (w), + * s32 startX (i), s32 startY (j), s32 startZ (k), + * s32 endX (l), s32 endY (m), s32 endZ (n), + * f32 normX (x), f32 normY (y), f32 normZ (z), + * FORMAT + * aaaassss eeeeuuuu vvvvwwww iiiiiiii jjjjjjjj kkkkkkkk llllllll mmmmmmmm nnnnnnnn xxxxxxxx yyyyyyyy zzzzzzzz + * size = 0x30 + */ +#define CS_PLAYER_ACTION(linkAction, startFrame, endFrame, rotX, rotY, rotZ, startX, startY, startZ, endX, endY, endZ, normX, normY, normZ) \ + CS_NPC_ACTION(linkAction, startFrame, endFrame, rotX, rotY, rotZ, startX, startY, startZ, endX, endY, endZ, normX, normY, normZ) + + /** + * ARGS + * s32 entries (e) + * FORMAT + * 00000013 eeeeeeee + * size = 0x8 + */ +#define CS_TEXT_LIST(entries) CS_CMD_TEXTBOX, CMD_W(entries) + + /** + * ARGS + * s16 messageId (i), s16 startFrame (s), s16 endFrame (e), s16 type (o), + * s16 topOptionBranch (y), s16 bottomOptionBranch (n) + * FORMAT + * iiiissss eeeeoooo yyyynnnn + * size = 0xC + */ +#define CS_TEXT_DISPLAY_TEXTBOX(messageId, startFrame, endFrame, type, topOptionBranch, bottomOptionBranch) \ + CMD_HH(messageId, startFrame), CMD_HH(endFrame, type), CMD_HH(topOptionBranch, bottomOptionBranch) + + /** + * ARGS + * s16 startFrame (s), s16 endFrame (e) + * FORMAT + * FFFFssss eeeeFFFF FFFFFFFF + * size = 0xC + */ +#define CS_TEXT_NONE(startFrame, endFrame) \ + CS_TEXT_DISPLAY_TEXTBOX(0xFFFF, startFrame, endFrame, 0xFFFF, 0xFFFF, 0xFFFF) + + /** + * ARGS + * s16 ocarinaSongAction (o), s16 startFrame (s), s16 endFrame (e), s16 topOptionBranch (i) + * FORMAT + * oooossss eeee0002 iiiiFFFF + * size = 0xC + */ +#define CS_TEXT_LEARN_SONG(ocarinaSongAction, startFrame, endFrame, messageId) \ + CS_TEXT_DISPLAY_TEXTBOX(ocarinaSongAction, startFrame, endFrame, 0x0002, messageId, 0xFFFF) + + /** + * ARGS + * s16 transitionType (t), s16 startFrame (s), s16 endFrame (e) + * FORMAT + * Capital U is Unused , endFrame duplicate + * 0000002D 00000001 ttttssss eeeeUUUU + * size = 0x10 + */ +#define CS_SCENE_TRANS_FX(transitionType, startFrame, endFrame) \ + CS_CMD_SCENE_TRANS_FX, 0x00000001, CMD_HH(transitionType, startFrame), CMD_HH(endFrame, endFrame) + + /** + * ARGS + * s32 entries (e) + * FORMAT + * 00000056 eeeeeeee + * size = 0x8 + */ +#define CS_PLAY_BGM_LIST(entries) CS_CMD_PLAYBGM, CMD_W(entries) + + /** + * ARGS + * s16 sequence (q), s16 startFrame (s), s16 endFrame (e) + * FORMAT + * Capital U is Unused + * qqqqssss eeeeUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU 00000000 00000000 00000000 + * size = 0x30 + */ +#define CS_PLAY_BGM(sequence, startFrame, endFrame, unused0, unused1, unused2, unused3, unused4, unused5, unused6, unused7) \ + CMD_HH(sequence, startFrame), CMD_HH(endFrame, unused0), \ + CMD_W(unused1), CMD_W(unused2), CMD_W(unused3), CMD_W(unused4), CMD_W(unused5), \ + CMD_W(unused6), CMD_W(unused7), 0x00000000, 0x00000000, 0x00000000 + + /** + * ARGS + * s32 entries (e) + * FORMAT + * 00000057 eeeeeeee + * size = 0x8 + */ +#define CS_STOP_BGM_LIST(entries) CS_CMD_STOPBGM, CMD_W(entries) + + /** + * ARGS + * s16 sequence (q), s16 startFrame (s), s16 endFrame (e) + * FORMAT + * Capital U is Unused + * uuqqssss eeeeUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU 00000000 00000000 00000000 + * size = 0x30 + */ +#define CS_STOP_BGM(sequence, startFrame, endFrame, unused0, unused1, unused2, unused3, unused4, unused5, unused6, unused7) \ + CMD_HH(sequence, startFrame), CMD_HH(endFrame, unused0), \ + CMD_W(unused1), CMD_W(unused2), CMD_W(unused3), CMD_W(unused4), CMD_W(unused5), \ + CMD_W(unused6), CMD_W(unused7), 0x00000000, 0x00000000, 0x00000000 + + /** + * ARGS + * s32 entries (e) + * FORMAT + * 0000007C eeeeeeee + * size = 0x8 + */ +#define CS_FADE_BGM_LIST(entries) CS_CMD_FADEBGM, CMD_W(entries) + + /** + * ARGS + * s16 fadeType (t), s16 startFrame (s), s16 endFrame (e) + * FORMAT + * Capital U is Unused + * ttttssss eeeeUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU UUUUUUUU 00000000 00000000 00000000 + * size = 0x30 + */ +#define CS_FADE_BGM(fadeType, startFrame, endFrame, unused0, unused1, unused2, unused3, unused4, unused5, unused6, unused7) \ + CMD_HH(fadeType, startFrame), CMD_HH(endFrame, unused0), \ + CMD_W(unused1), CMD_W(unused2), CMD_W(unused3), CMD_W(unused4), CMD_W(unused5), \ + CMD_W(unused6), CMD_W(unused7), 0x00000000, 0x00000000, 0x00000000 + + /** + * ARGS + * s32 entries (e) + * FORMAT + * 0000008C eeeeeeee + * size = 0x8 + */ +#define CS_TIME_LIST(entries) CS_CMD_SETTIME, CMD_W(entries) + + /** + * ARGS + * s16 unk (u), s16 startFrame (s), s16 endFrame (e), s8 hour (h), s8 min (m) + * FORMAT + * Capital U is Unused + * uuuussss eeeehhmm UUUUUUUU + * size = 0xC + */ +#define CS_TIME(unk, startFrame, endFrame, hour, min, unused) \ + CMD_HH(unk, startFrame), \ + CMD_HBB(endFrame, hour, min), \ + CMD_W(unused) + + /** + * ARGS + * CutsceneTerminatorDestination dest (d), s16 startFrame (s), s16 endFrame (e) + * FORMAT + * Capital U is Unused , endFrame duplicate + * 000003E8 00000001 ddddssss eeeeUUUU + * size = 0x10 + */ +#define CS_TERMINATOR(dest, startFrame, endFrame) \ + CS_CMD_TERMINATOR, 0x00000001, CMD_HH(dest, startFrame), CMD_HH(endFrame, endFrame) + + /** + * Marks the end of a cutscene + */ +#define CS_END() 0xFFFFFFFF, 0x00000000 + +#endif \ No newline at end of file diff --git a/OTRExporter/assets/ship_of_harkinian/buttons/ABtn.png b/OTRExporter/assets/ship_of_harkinian/buttons/ABtn.png new file mode 100644 index 0000000000000000000000000000000000000000..c1b06571c3a9c4427420bcbccec364f28c7c4778 GIT binary patch literal 10967 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 v@qKsBw zA-MLRkMZ;AIBG9E?7PxJLqXJb=tmpoN{Vyy#p^F_SruqsdHZXH`vn3ukSB1w)b(LzMHoA!nNI)eHtru z*o!%83oRtv;nxMfo4y^_KkmDd~=SADu5cHhj8 z<^3iD>*g!J-&Eo;YlTSpxlMMINteSX4|*(RUNR3?My#_B4qJ-Mj=k|d7I*R)E+obt zo8Ss3(k4PrQ1+S|4P5zzF37Ez01i=KJ%6I&Z0*eX~9;ib6ESz9c*qd5mL&!=36qK zydpYM>c+tQG^zK4)A1_xSD9ivRu<0X3`xCTP&5!+DRs#rEX`Ls?Pd`8_wOK=TuELs)&KI+Z5?a0|&6J-&xv)bZ!jDqy9tGL&XvB)CU*sauZW4+udB&cjqh$UbyaRAG#|4(@r0)=Wl(>)F14LZm3lVCE}*P&D+(^2UwxMyAgCeFcmmSEJq|n_VdP`F0r9rPFiuV`-Z-SJL9z`1blaF}b~=j&{7| zmhFjIt|Bn~>HY>6{g+Q$jhOAzExst!e;|nCCf2muApAs-=swFGXP;!IbWJJDZcMkT z3Pdy72iwnCh*Xg7d8r#*`G&ic9e5+)3Qh80*sJW!oCNB@^a1(I(;L(yDnpy|hMs0T zP|?xZ8FDn?RoT^w0Hk*Oo%frU3ZJ38*D1e;!d>X2ZSNM#Z7r<|tuQYrpZ_AbKX4uu zpYw4V-gBVhWrxDdMvbGoXVRV?NP2WVW$}!SA9vNzdseM`Jp=!UbbMM~NP5gvv(Q;7 zP71s<{fjL}&d%6_tewAjHflwT7$(JGb%ksSy*g~y3Q}21nX|}WXw14p#JI_)A~U$Y zLmBvLF?}zSrZ>lG9E~MPU2=49`Npceu2~$~mz00Jw>#LfL#H(6$;>H)W8!+v#Ti#G zck}dil?UmqmkjTmk? zgYA7U1_CE}6Sr{i{Z+|XF+?32^3owd5N~CYnzLb;V;9lSNNT+E1D`Aa4mQR&fCn} zyEFRvi4c2XF|1*b&V`Jp{Rxis*)kpXeC3+53X0n9KW+KYkgjy?zJ%Wy^TQ%!uei(8 zb@5%hEZr_1ost!r^(|^u@rQhGPw`}K{1l85Ne#QS)hk-A@20}s`&x4HY?GLp8&l_s zR`Ede)Et~#DRw@A^j0Hd zJvJ@Dt-PXCC9>7fPs`S~JMNHU&}rsei-P-(xmqigdhDhK*S5aXbuaLOb2;We9 zw|2JbCdZ7g2j@q`$vRAbUzKc1alW}QYL%LpL-LVzx>f00reBNb3^`}BtLvSeLWH7x zL1Yzc&@1$1NY-BK=fuxX_SGK@lq<;|cxLZ>Z1M3FM{?zsmt`+IpOqEir7y>%;Tt*v zmwH#+sR7B9TpUtIA6c@6AEi7VH|luydP*%;gr*$d)jN zm&Wg+Ri8fY&|X!m_iWxZjBWCrGV@gmI7x}K3tz$mf3~}#}w{KRqn0x+?Yod zNS1y@-5WXm#zq1tp1`n17|6Z+-Gca!!j?GTTu|%lvjVkjA?ZC zjy>_KUd&KnNqM!xrJ+2L8d39w^~e}PT$Ogy%U9I};rbDmiw&k0dfwclzW>76(2$@; zM=fQ!PswZBB;xh*9xjjZG`jXIR>X#^(^}`_BHDF}cU0n*{*ss+rAA?HRYTdVf@=R) zP1;RP)V3SOme*n^%6spLr@m;HiSMQiX?U#6dxmYNq_)^_F7dW?560fSB(r?m@u>BtFBUxC#%9u}iq4ryK(5`BZ!80ui-x&`EE^x8TA9|fj4#}>$ zvo+q-Z)@OwT9IRD`g282+}YVGww`r5(-4+-!=2TvZ#fy?IN!+~+*KZ(e*zIXBfaI6$%Ru^`LU?mR+vnp&_n^^zpnz&_I^(P^^S z`Q)O+JvrxHi_R&U`})c_i%D)@=D5%~mdj)nd7>qrcW|W?T-y*jd3{y!XH9cX zh_@fiWUs+5tCgrdVX?a5zSRPD{1?j$aWY^%7G4? z^qnl$5Gf3AbrO|9rm6G1nLu&CU^@CdCW*3{#(|S*?sOkrL|fWJ1e{LQMXbeHXjm`} zX&!X502a+Iz|x))u$e-jBJ}m9>+pyGfH#dpg7dt+eAq;uE`pCs1nxmI3IXT4a5n2A zoGh&2h71-Bj#bC1Yaoqz^eq^K-gLMQi|R(SH8L520D8Iz4-SV(M4|lr{M7w4)fp^z z6q-OFpfoTj3t zf%5kLA%e{@-twJq%m}tU@Pi9wOJg&*EDFtd3(be4BuL8i;<5!fxojF};_LRJx}gA3 zd}hHIQ*#UJ(HJm|?sRV^KLYd?^rTWo{g_;q7vG0ULD9Tu-hdD`fQLWHg0~Hj+%!#34x(Z3-TT!)W5k z1OW&u79A*Ul9!+=5Q+*wxoMNhBs9(qNv2Q%C;~+bNuXiSNUEC~PMbob;HfxmJ`|W( zqJg!!E&`*j@!ewWMdG+ISl+;Tq5Du7e(di<_H=KW9ft&_4XuU6Y2nalj3!1~Q(GJT z-N}*0Vgq#xqM|j_(ZgI+3eg0>Bmwn9_a?d1P)r|peh8qNXvm_GI1H9OgW;u%09C=k zQ2uIw>x|SnaSek)0@nlInMMVd%E)3_NpeT=yE>>}IsXmG&V%9SGcla+uA?XhERG+8 zwb_bgMfRjoIKRdj%Xt*Z7TBiP9G1WNZzlDVpU!Y$ngOv4mcIbM9nE*RH@ug4(fO%@ z!};r%NTPsQ)J3pKTWD1NBLMO^JVfyz`MA@7jdEm_Kz8~V1&bq~F=QNpfYj8ck${@V z5A_D;ZAITr(_rG-gm##m`z#lpPS6%<5>yI+EC}V(|mw)pC9l`IA&&R81O54DtWc35o`$jJN@7yXc1+atz*MrVza=H5G*Ek z4q%+dF}E`XN-d7m!~Caq>}WMJ9VX%hlm{`hLSOBnh&Xt1{lHrx8m zALC6pU@THW5ugC*>g?)*DLXe$2>Z8AV-X9IL8MR%k_%qH6Y@&|g5)@;U#N42;P< zj&c0*90@oTRu7Yz^F1>%@bCBIU;<`Q*vGfSJEDR4r19N=5#ih@nct@WW8?Sj6$1Vh z>hF9E(BS{4!1#}W{|KNhb1YD@_k6y2q9O#zq1lgx-vksQ_?b`*OjN{J$n9 zgG7Mj6Cnm?e=PY6A0{>bE1!Eb0}%L=;%~5tihzj!lpNv$+tF1(3T_|GhM>cE_aNy+ ziJ|8XVL`J8`+p;a9)+6X-;x8xPpJKw^ykz=Afp+83{d;3=KDbsvQ4A~iN_-!EBqo^g4` z9e{!bML@Rk#5^ec24rk_gMoa1MGpG>RsaMfC}))A=R~9q^@@2Dx^Zb zL@Du=NJ-K{NvM=o)NQf;KA)*iMvC0u{r-1PubFesbDrmUzt3}?v&`$&UI#l18Ogbl z2n0gL%F@gctdY=X+EnnHzinGD0x|vJHfJ}1BgG%d<#8A+ZvZI>iXC;NQ9Rj@fz zcMZ=MdV=((Qhk@3653Srye_+u3i@81g2LSI|hS_I=p>>XF&v z)lQF>1Qdiy^##S0gdXRp)#m6un{&IqFpgQO>x)@sv@)kZ*ZqU)aeL#C1En>sh9@yM z`#X=xc~IlK=HLe2Mnq$JUOXu(;HaqX|JX9`c3t27qaX77mv28`a!pBLrmg--y9@PO zlvO*z43d%;ZHm8wEo*TJRLoX3TG@HwXbrb2(BVmux&B6eT_%4%do#7Sgn90noLbq2 z=}%k@LtoDNt2z6@i3nxM%`ycx(`-K6QS$H0WEQ-TTw#Cbq-01Va3K8uCh? znVL3v2U5c~ZVEi0ye}!_-K?EggBurX+&Et&QxM!J=RC!jNYNrZ_AZENeYx_gqHNi& zmaz6CCS^^57^6Lp*JF#O%(zfIWoz-1j$pro1SN!*TbF6?{K-jslIOgpO)F09pvZ3T zN$e>5&!(Vvqyu_lVUf1V-d>(N6;IwsR*_Qil3%#bGHUs4%Of!+`>Y&S6VvWqR^gRK zIhEx!C9I#mNJ%rT$#FG0^Znd%qqMYF?p~RhfsY=a$y(buSY*>r?tPqk`q=i@m#>Hg zuTsHR+&%d_skT?!hE6>d&y4rYZZ0*^T)W|7#l7^5+}emOD>|+Mr;qwS@x3B(d0rLg z{El4-*Vgn%Xa;K;p22P5g`i(J+nM1e;ne2uVVWaMw%;yQntjr>X_of-!&yjGb@MFT zBTcH&oY3w&)G}jji{&;t9w|aNH-+jIx zi`4O-L!ndX4H*WtErh!G>|1WrS_c`y$$`!r(`_`Iyfzj4OqbFaY|!4CsJu0aCTPK; z?)OMWwCXgt`ey>`bi4JE+-Jvz;LWloJ!lD@caGt2 zG_S*CVk31!vuI&e&mX%-Ps3E-=)Sr=HKS#w-c3r>fo2oK^r@DT z3YXo~0ul{Rw;ys{G}SsxVzI(<9EQHKKGj{`DqcD`IIzd~O4_oO3j1AeA0qTEP_jV-DO09+B08n)xmml@jnnnL8fuh# zn-3MbG-15sW?ZZ3zEIn(OwL&<7C~8c54{QZuKa<_NCxy3M;TX5F zSM{I*WMOK8 z7KBESZ*A7fcCy=Mp17o=lI<0kTm2{~z8zm=mDc$pYjBx~Q&(=V@uoE$HJ285dXw}{ zrp>B8#+lDP9Fyu%=j!}-zs|XqS!KKaA}+Lr9L(98z1o{cZeb4 z9ccfQv%dic3GJ4#k23(3>V-LPu7)koFiI@G2K&dpV@Z8mSb$Xb$iUMCIf7Qfoe%_h(+le0cmZISZbhvrdh_la-6 zQ^;@2OMkermb`RodzYlt1(2Aog6>%$Qfa()C1#W3_APz@NFNJM{OH1s5V!-EpKo@51A_P(R1&ke8W&SaY-E|O|C1KGJ@k02cjzPahgQ80 zpT=H0|M>PmVv(HgPSsOUvp;RKk$=#VVE21@_bosAS&#QJb+??e`AMW>`Wam+2Z&VU zW;&>)2e`TFyQtuj96b&j-X)D9H*lLzSOia!yOF zoLpg-Xu0p5&hfIxB}n4=OwU5jOks4#p`CArDvOZFnuWu7xEt$pP!o)pk@OIyTo z0)?Q5Ci!QMNOf(zyz9(PtK&DH)E-<<_U?>L(bBnAfjC$ti>vrxbtLY^m-b@$|90o= z7s!@0zfp|2c{r#y_~7Ywm3xGAzvl#tMP=8cA03W46_H?F5tQ9>eyU=8`<94nb&)S? zTRyK#{p@s&LU7GXIfg%S$y3GtHE)0C+0KRcE;@T&5+mlBoeKQpg;VV(E}`fhIekzK zHD&sz+=2r)z&9Rq%*P#zE1*G-JF<`tt7ZolG6N;speW%*GFj_Su9^!+m(JtfmN z_D5%<&2+PkRB)^J7$P2sce$^)`KMTsK=baAQx(x=_v~ua%a*zf*m?Jf|J5{`DYN3j zO$0(LoMme2U}b6wzb8SUq~OD3%Ueb&w>_LvQHm1F_7Ui3WU0o^g=@~bO_oZ{EI+%u zIMt&(Wr5Y!t+O^r$%ZUnJAXrxuP;||@=duJ78)Anvo+uDusUJ>yTqMO0sh@v`((V`WtFt`9(A#q__Iq+NK4Ih*LAd6 z$TDnup~m|-ombqnbk|{;nBtj86~h6wk6qQJ_O`iJHkx_KbdMWY6E zdH$=u>Zf;JPl`NsE{3ynx9R3fMo-#RySu!)I~%m`e-1$e9p$Bm%!zq}K*+hUzz4pY ztqqCB@zJ8tIaEL^z=sPa2LfSW7{H~_wg3Vo6=1U1WK{RH0u+)(C!<_-ZLzjoQ^1pD zxs3-nZL@QxZQDX4(ou#hB@F^dpaUO3KtTrhc(eJW05VGGmjt#UF$RScstC4_QEs*l zNK+0EKDa@aYP@8$uZ za2NpU3*GYtbc_|)(E;ZJDq!$fECG$hqwz$Hs69ApYdd1i<_|{^j3*|5!o}dUuoxeo zZ!Gu%bHA^6V_NW?!QWXJM}W`q<$O72kl1;#+;7OxiC;9 zGY-uc@?vF1MnMEfbPkP0CkdN)fWW{~89HbNo~DP^p%W=+0s#x4=~N;^M^~SSr8BT1 zuB_O60fkKiAXlJsEf(m9LSX0+b--+(>QQvjI@)*~nyO3JM-z#3Z9N(TN5unxhzolj z3ruZ_wz_)5YPiIyj=9j<)_+rL_Q$ z59Tf86^GTr5riXj8fg{ilLF=s%ZI`QFkChho)5{C2T%kYo->EzO-4aLNXS&U8;}OW zc}}w7&?wM;5Gn(7XsZlw7842+BkUSrex&@JCnryiKYL<+zN(IRG3E*UIlL|QJbS7a zKok7f&sfSMo*cnriZ9>=TK!~Fqx1}h64Mg280(A z(<9*sB)kr4Xtj|B80ct(XKMf*9=5h5(Rdg@hYQIHN;oH9F4vm{@V<=`oHyg>iP#V4 z=+DeW)rPE1Iov>Sw|WZf{nz5+%OUnOd*FP36$*;ea z0XF#V^9O$kr!1_u1Aj$NrCM8RV1*ATd9`5BQP5)cLd5vV92+=hsB^?Vj~^;jL_ z;*2>U3JiJpRdC1#CeZ$7hy*0F4($34?>m7g_}>ABfS@9}6i*sI4hg~U(Imu2Murl#w2CFdooox#+B6@X

z`w)pXaA)jg$O+DBgr4Fcyi9=ilD_quKpz_K?2t zHiVBx9nBe|eT>9<04a;^g7FAMo%;)+G-DFtV0y3Egd+eshmKh2<3f>xx+7(D zBp~4Nz~S(>z4;`xAGs%?^LeZ@d<11w!`NyPqTtGq6KDt`0VU;lz@yAZx+4#gWWO20 zvze>~{qNeZ6;UD>gAteCIe}(>IP))|JhyaEsQBFy+^QHlp}w;oM*z+EN1(8oC^#&G z>Jb8zeQ(C6E^0B{9=*;GiLr=4!0@`mZs6HN{qI2GrC7FLBt2leU#drgjt)KSY$O7( z0IsVVzCI*j*+lBGW(^?rot>qj*7LmFc& z0XzWJ@T&!CFaO0QfxzLCa;<;Ni9+M!4#38uBw*QiWb(`2gAx0BHbDA60*A(bN&r%V ziYO8IE*~2C{u?6kGhoVMyRt^6u_PKZ_A!y{rm|#>gfWYTVVD^PA*GVMN}HvWHzh5viWVfK zsAMa$Wp5EJNJR+W^NdELNcz6-zxVjfJkN8V`@XL0+~+>$IrFP%YfCe}#gdC55C|W} z+}H-VLctIB0^pk#67mTGSv)_)ZZq8m%Ygb(DMS*P0Hp`}5uk)15)lFkdX|w$%2HP5 z-#vb9zpJ4tcM(-wHe_M`*D>Q`VfPtsh5ObPXeHi-9=&ih$9ME~ThnMvVbGrEhqsk# zzK$uhv*nAm%}Jh5;=nU1GwuZs_yGdOlZu6`Y>!#K5(+Byf~$ux(J> zdo}ez^njBuPinpqIo;>B>i+bkf`e}=BZpV-H7bzmt#z&UTo~rxf9Z9>_VJdH&aaP8 zefUz5F!Vv_q?=68kk<0HrrlM`9%P$zyp2R(8F+!J+TQCl;5yjt{3u96|1Wgqz!gGb zgMYBDe%bA#*^lc#Uc9}yi5HqupM$>AaY^9stdmyZ!=2e~>C)lu9*dO~eYj#*f%sLmn zmo{we4i&v)@(wQkLYCX5(d`d-yqBmj3jOnY zB9B(oXnXyIuB{hteQC_AF33|FnIp+5h!!V0epof%s1li{^hi|R{j9i_Z-@~ucTK;+ z%^kSGoz3IBPaNsj?+_j1*YSKjsvk#NH@GC*&H97_;{`O(?DWv5{l+p?jwF?%L`=r$ z*1V=ip>-8j^~u|{Z&(aCg~7-fU3CSBWl9`*>12tTBaf7qMD-*wYIX87-VQXH6>+9g z9L^2sR0dvtj}qk!DcE}2O1idAsiy4cMdcB=zrXodKncZG=z)&u;Bwi1-78&vmONnr zZO0#7yw%i4-0D1l5i2=RUOy`COJuCmKH=FX)o`oTpuA=%D#J3C6Xl=cBcCgu{iNxy z$`g30{VvPeE1r)$3@gdJmV5iXoRiopZ;Uw1t4g`t`0El+oxSJO3eMCnZ9VYfw%3@L z)SZKdu8&ErQIYb84xG?4ipII>tDJ0fx#ccMQo!yyUDMWu^n-`({P^TnFPFC4JB{SA zzOxqG&#<}VTTsVQNyFWji{9nNOPeSEvsNKWYW>l!k!CI#dQ2L%X;avc`hp(4_6`p6 zZr+Uh;k9+%9eu$Y3eLfxXw%9g$3|>$x7-3N!wqs$F_f;a8IDfaBoLx5bf+KxA%ebk9K?@Y{q$8*5Xafd<Sykbu!tK2&W9^Z`f;aVn?n{rK7 zXG=4V_ko;sR>kLxgh%iD$ZhMx8nLUoPyIs(?$=u=-E`aZok{%#gO`|Oj+I~2)W#($ z%OnnW_DWsoI-l8_%zdgRN;~8AvEK8PlbmOc9=bka8C@&mRR)ue9mqNT>Z{YT)elQN zbSu#PXJpE*nTy&sk8-=Y9LjpC+L+k9+B^N!qPut@$OZ2nsYtgoJCa@Fk0qTUt(DT{ zKl?6>qkAkuF=D^Tn!QJjk99Z6@b_@5n_d{vO0=eRuT3jAnxC;?WRdBH5ZT&clzf_i zi`x7sWzn$2f_df3|{1$J00FKoykh_@y*;4p_`UlP7asAoi%&%MEcc- zcF3C~iCH3hu2lC1<_p)SwkI7dzG87szV@Frd)IrOY}go=6PsvTp8h2CS^t1YR9l?= zxWQJ5-3NW&$i8qcUAic*HM%o!_Y*^mnBAAIa&kleb7PVyp+ae!G+#%7rR&I}=w7%~ z2iYaGb6!Fpk^3LR9`{NbDqH0FgKA2fuujT)n@97@6gs(-_J!`mo*iqfMyfhx?KeJb zv!PwKUwjxF&>i8ibbb5%uyZ9>U*^0`j)2`H*j(4;YPZ%1$+I{aCsQ%hYqew1PMM6& zd~t98=DqES3G6O@_yJp=XZ$gUWBY{-T-tXUpY(`WE-~K1FFro}RNr}!(7yJ= z`}m@Oa5}lM%&Yo3+B#WTl+hU+vtTI8TJ+AfY>?1hW&{BxYq#!P4QXc zgT^&+lPiSG?)s=6O768ILbUmZrHqKDz?r z@4wWAhd+F^gS1O>K!BgfydnWXvz04N#8!RSfjMpR*TM&*L5yDiL4LtEgmcHGmqc82 zGF1~5QE#+Y?OV*j)nx|339Ek&@>1oi`Vb%>8LOxviv`Z?e8 zB#RBNZ(B)um|#|{UAbJlYgh3>mxQh1FI@aKw)ge*JtdEfG~8UaGGbgJr`maJ zy>#NJTz*~kU9)w)T7Ld5)i3qhsSCwJtL2TTa{3l4QWmyWb)Cps*9L!_-#Jj%{GgjF z?%d^gN<^fQ`}K8=Zc=f(-Q?D2chlHM_UJ4hF?}I=D>`B0ng3T5i(Kw2a3KmcC zAgBcS_yNTMf#~W7`C)P11Ul4%;7Rh;gZ1VW!k{F)9?VhG0%_rAMA$|$51|rlLoDrZ zA>KG0JWPM>V%;D#0N_KQW1&GlWM3LONDs!uMFaPs83BVbUFhC=u+0|MP$LSJ0M$^@ zP(i{?f=GdCu(gY!x>P(7ZDVZu4FY)5gKeYJ{m=*mgTYW?sH;$@o(NSP9UTNx4WXt6 z2Rz`kU|%{m2<}Uh1tBIdj0rRx6{u(u#TN=Us2$~)6+YDhtpiu&-ID$za!Iv(}PU=Svps{lX&6kGs^ zf-%;EfdbHY3XX(FGjBE2iAbb2jtJMnt7*VBh)6sfg;dAGJv2462q-NS5s%kkgTnaI z=vZGI0fYj;RY(AiIv$Bv#}f!}ybciy*T8CP!*#TX;anG(A3gYMXDn;bTqZKw7)w!5U4bu zZb4L4q>AbU7aoT;1u(Hd{g8aHo&nXC60md%)s8|T>%l-(P%xCa8lbx0 z>Kwh1g2RIAf$2=ZgG=SxVll*eBAAc5h+jGXgk-yo!tnh)obRraC3?9 zZl|h+R@FuWg)uSPP+bJLHL^yl3vM137HIZ-=z^OI8Uq%bZGfL2nM9yY%@eC`X7FQ+ z|5l^3g|oX&L>p23f`Qe#jc{U!Z0juQwQNjQQpjq)q$>@E{&VS9rBnkQ_)n+bT) zAtv8+->L*$NdL$7t@{3t3;^`MBy-B|zv=onU31F7oSgryu7A@trwq)=`QPgLpQUT@ z_ut9{U*O!w0DcL_V0buzU(pLZHkcVh#=*b8^V5$2mPLN%PBaLFX9@V>fE-U22aF5p z7z>kyot$DKLW_kJO5Q;rg31_U1G~+OIG}=Uy&QncoZH(Ro$()o#=dkz#H?HAjQ86C z(~+`^00pqx$4{RiaxQOv3wu_l>4@3MSfs2gNY3776Y@&|?Bu^9WhZ3agF<>fjxis# zNbhFknYM$S7(|#WIT*td@V0M41Zdk3-18IPPX>1KKOqK*z{WlmjW51V7=iB}MS$yR zN@J0-u2VYy@L{F&ycr{>2>>?%w%ms8d5z`F>ToEFI6LfESzZWLc0*)ROz{kt`OC3w0-~0bG8=#0cz{-dw z@-sQ-oB?(bpxW88@yihbopTld0{$rC)R9-S@yyuI@hD;GxG*2*tmy|4?w5^D0eaW| zecOH4HF0l`6`10~dSLB}tmne2VdgC}13z}MoMyZJm`@4d{7;C%(I3kA z%mlwxKE&kysR-{?PwY_BNtlit9P#grnw^{-dolx{@prPo3jQ5Z(3dsm;Qf!I2W?XX zfCiQbBvF*Pg4LI!B*S${UAAE`MqzDcqa1c5Pr%4=)}qbcn=;P z3{+<>Owi{?LeK^_aJ{pieprP!(L3=ytpJt->(l~1ub$(Sur?bo_H5qZj65@TfPr9R z7cpU(SxkQAFp#mSXNF&qgLtzFV3D#50pH`lYM_YOh*|N!Er1mOUa9uHQ_l9RK5%bm a-T&@2YJoFO%U-?#^v9T38ecYa-}N5>&$}J~ literal 0 HcmV?d00001 diff --git a/OTRExporter/assets/ship_of_harkinian/buttons/CUp.png b/OTRExporter/assets/ship_of_harkinian/buttons/CUp.png new file mode 100644 index 0000000000000000000000000000000000000000..6c0e29d2de653af5f5518cfd1c6a5d3b956b1e33 GIT binary patch literal 11219 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 literal 0 HcmV?d00001 diff --git a/OTRExporter/assets/ship_of_harkinian/buttons/ZBtn.png b/OTRExporter/assets/ship_of_harkinian/buttons/ZBtn.png new file mode 100644 index 0000000000000000000000000000000000000000..def8d9a6da2fcab6486b6106064d9fcd11dd47ba GIT binary patch literal 1241 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 Z>j337)B>e!)*=7^002ovPDHLkV1hYRW_$nu literal 0 HcmV?d00001 diff --git a/OTRExporter/extract_assets.py b/OTRExporter/extract_assets.py new file mode 100755 index 000000000..404b49ced --- /dev/null +++ b/OTRExporter/extract_assets.py @@ -0,0 +1,117 @@ +#!/usr/bin/env python3 + +import argparse, json, os, signal, time, sys, shutil +from multiprocessing import Pool, cpu_count, Event, Manager, ProcessError +import shutil + +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") + + shutil.copytree("assets", "Extract/assets") + + execStr = "x64\\Release\\ZAPD.exe" if sys.platform == "win32" else "../ZAPD/ZAPD.out" + + execStr += " botr -se OTR" + + print(execStr) + exitValue = os.system(execStr) + 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") + args = parser.parse_args() + + global mainAbort + mainAbort = Event() + manager = Manager() + signal.signal(signal.SIGINT, SignalHandler) + + 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") + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/OTRExporter/offsets.json b/OTRExporter/offsets.json new file mode 100644 index 000000000..e03311620 --- /dev/null +++ b/OTRExporter/offsets.json @@ -0,0 +1,8 @@ +{ + "MQDebug": { + "bankdefs": [1281424, 128], + "fontdefs": [1278576, 624], + "fontmaps": [1279200, 448], + "seqdefs": [1279648, 1776] + } +} \ No newline at end of file