Merge pull request #148 from coco875/unk-spawn-data

Unk spawn data

5 files changed, 146 insertions, 12 deletions

diff --git a/src/Companion.cpp b/src/Companion.cpp
index 5615cbe..f489317 100644
--- a/src/Companion.cpp
+++ b/src/Companion.cpp
@@ -49,6 +49,7 @@
 #include "factories/mk64/Waypoints.h"
 #include "factories/mk64/TrackSections.h"
 #include "factories/mk64/SpawnData.h"
+#include "factories/mk64/UnkSpawnData.h"
 #include "factories/mk64/DrivingBehaviour.h"
 #include "factories/mk64/ItemCurve.h"
 #include "factories/mk64/CourseMetadata.h"
@@ -117,6 +118,7 @@ void Companion::Init(const ExportType type) {
     this->RegisterFactory("MK64:TRACK_WAYPOINTS", std::make_shared<MK64::WaypointsFactory>());
     this->RegisterFactory("MK64:TRACK_SECTIONS", std::make_shared<MK64::TrackSectionsFactory>());
     this->RegisterFactory("MK64:SPAWN_DATA", std::make_shared<MK64::SpawnDataFactory>());
+    this->RegisterFactory("MK64:UNK_SPAWN_DATA", std::make_shared<MK64::UnkSpawnDataFactory>());
     this->RegisterFactory("MK64:DRIVING_BEHAVIOUR", std::make_shared<MK64::DrivingBehaviourFactory>());
     this->RegisterFactory("MK64:ITEM_CURVE", std::make_shared<MK64::ItemCurveFactory>()); // Item curve for decomp only
     this->RegisterFactory("MK64:METADATA", std::make_shared<MK64::CourseMetadataFactory>());
diff --git a/src/factories/DisplayListFactory.cpp b/src/factories/DisplayListFactory.cpp
index a596ab4..7464d68 100644
--- a/src/factories/DisplayListFactory.cpp
+++ b/src/factories/DisplayListFactory.cpp
@@ -296,21 +296,15 @@ ExportResult DListBinaryExporter::Export(std::ostream &write, std::shared_ptr<IP
             auto dec = Companion::Instance->GetNodeByAddr(ptr);
             auto branch = (w0 >> 16) & G_DL_NO_PUSH;
 
-            if (node["otr_mode"]) {
-                auto str = node["otr_mode"].as<std::string>();
-                // Too lower case
-                std::transform(str.begin(), str.end(), str.begin(), [](unsigned char c){ return std::tolower(c); });
-                if (str == "index") {
-                    value = gsSPDisplayListOTRIndex(w1);
-                } else {
-                    value = gsSPDisplayListOTRHash(ptr);
-                }
+            // Export displaylist segment addresses as an index into a buffer of gfx
+            if ((Companion::Instance->GetGBIMinorVersion() == GBIMinorVersion::Mk64) && (SEGMENT_NUMBER(w1) == 0x07)) {
+                value = gsSPDisplayListOTRIndex(w1);
                 w0 = value.words.w0;
                 w1 = value.words.w1;
             } else {
-                    value = gsSPDisplayListOTRHash(ptr);
-                    w0 = value.words.w0;
-                    w1 = value.words.w1;
+                value = gsSPDisplayListOTRHash(ptr);
+                w0 = value.words.w0;
+                w1 = value.words.w1;
             }
 
             writer.Write(w0);
diff --git a/src/factories/ResourceType.h b/src/factories/ResourceType.h
index 2c94ba8..e3eae80 100644
--- a/src/factories/ResourceType.h
+++ b/src/factories/ResourceType.h
@@ -46,6 +46,7 @@ enum class ResourceType {
     Waypoints = 0x57505453,        // WPTS
     Metadata  = 0x4D444154,        // MDAT
     SpawnData = 0x53444154,        // SDAT
+    UnkSpawnData = 0x55534454,     // USDT
     DrivingBehaviour = 0x44424856, // DBHV
 
     // SF64
diff --git a/src/factories/mk64/UnkSpawnData.cpp b/src/factories/mk64/UnkSpawnData.cpp
new file mode 100644
index 0000000..8486678
--- /dev/null
+++ b/src/factories/mk64/UnkSpawnData.cpp
@@ -0,0 +1,88 @@
+#include "UnkSpawnData.h"
+
+#include "Companion.h"
+#include "utils/Decompressor.h"
+
+#define NUM(x) std::dec << std::setfill(' ') << std::setw(6) << x
+#define COL(c) "0x" << std::hex << std::setw(2) << std::setfill('0') << c
+
+ExportResult MK64::UnkSpawnDataHeaderExporter::Export(std::ostream &write, std::shared_ptr<IParsedData> raw, std::string& entryName, YAML::Node &node, std::string* replacement) {
+    const auto symbol = GetSafeNode(node, "symbol", entryName);
+
+    if(Companion::Instance->IsOTRMode()){
+        write << "static const ALIGN_ASSET(2) char " << symbol << "[] = \"__OTR__" << (*replacement) << "\";\n\n";
+        return std::nullopt;
+    }
+
+    write << "extern UnkActorSpawnData " << symbol << "[];\n";
+    return std::nullopt;
+}
+
+ExportResult MK64::UnkSpawnDataCodeExporter::Export(std::ostream &write, std::shared_ptr<IParsedData> raw, std::string& entryName, YAML::Node &node, std::string* replacement ) {
+    auto spawns = std::static_pointer_cast<UnkSpawnDataData>(raw)->mSpawns;
+    const auto symbol = GetSafeNode(node, "symbol", entryName);
+    const auto offset = GetSafeNode<uint32_t>(node, "offset");
+
+    write << "UnkActorSpawnData " << symbol << "[] = {\n";
+
+    for (int i = 0; i < spawns.size(); i++) {
+        auto x = spawns[i].x;
+        auto y = spawns[i].y;
+        auto z = spawns[i].z;
+
+        auto someId = spawns[i].someId;
+        auto unk8 = spawns[i].unk8;
+
+        if(i <= spawns.size() - 1) {
+            write << fourSpaceTab;
+        }
+
+        // { x, y, z, id },
+        write << "{" << NUM(x) << ", " << NUM(y) << ", " << NUM(z) << ", " << NUM(someId) << ", " << NUM(unk8) << " },\n";
+    }
+    write << "};\n";
+
+    return offset + spawns.size() * sizeof(MK64::UnkActorSpawnData);
+}
+
+ExportResult MK64::UnkSpawnDataBinaryExporter::Export(std::ostream &write, std::shared_ptr<IParsedData> raw, std::string& entryName, YAML::Node &node, std::string* replacement ) {
+    auto spawns = std::static_pointer_cast<UnkSpawnDataData>(raw)->mSpawns;
+    auto writer = LUS::BinaryWriter();
+
+    WriteHeader(writer, Torch::ResourceType::UnkSpawnData, 0);
+    writer.Write((uint32_t) spawns.size());
+    for(auto s : spawns) {
+        writer.Write(s.x);
+        writer.Write(s.y);
+        writer.Write(s.z);
+        writer.Write(s.someId);
+        writer.Write(s.unk8);
+    }
+
+    writer.Finish(write);
+    return std::nullopt;
+}
+
+std::optional<std::shared_ptr<IParsedData>> MK64::UnkSpawnDataFactory::parse(std::vector<uint8_t>& buffer, YAML::Node& node) {
+    auto count = GetSafeNode<size_t>(node, "count");
+
+    auto [_, segment] = Decompressor::AutoDecode(node, buffer);
+    LUS::BinaryReader reader(segment.data, count * sizeof(MK64::UnkActorSpawnData));
+
+    reader.SetEndianness(Torch::Endianness::Big);
+    std::vector<MK64::UnkActorSpawnData> spawns;
+
+    for(size_t i = 0; i < count; i++) {
+        auto x = reader.ReadInt16();
+        auto y = reader.ReadInt16();
+        auto z = reader.ReadInt16();
+        auto someId = reader.ReadInt16();
+        auto unk8 = reader.ReadInt16();
+
+        spawns.push_back(MK64::UnkActorSpawnData({
+           x, y, z, someId, unk8 
+       }));
+    }
+
+    return std::make_shared<UnkSpawnDataData>(spawns);
+}
\ No newline at end of file
diff --git a/src/factories/mk64/UnkSpawnData.h b/src/factories/mk64/UnkSpawnData.h
new file mode 100644
index 0000000..0467c31
--- /dev/null
+++ b/src/factories/mk64/UnkSpawnData.h
@@ -0,0 +1,49 @@
+#pragma once
+
+#include "../BaseFactory.h"
+
+namespace MK64 {
+
+    struct UnkActorSpawnData {
+        int16_t x;
+        int16_t y;
+        int16_t z;
+        int16_t someId;
+        int16_t unk8;
+    };
+
+    class UnkSpawnDataData : public IParsedData {
+    public:
+        std::vector<UnkActorSpawnData> mSpawns;
+
+        explicit UnkSpawnDataData(std::vector<UnkActorSpawnData> spawns) : mSpawns(spawns) {}
+    };
+
+    class UnkSpawnDataHeaderExporter : public BaseExporter {
+        ExportResult Export(std::ostream& write, std::shared_ptr<IParsedData> data, std::string& entryName, YAML::Node& node, std::string* replacement) override;
+    };
+
+    class UnkSpawnDataBinaryExporter : public BaseExporter {
+        ExportResult Export(std::ostream& write, std::shared_ptr<IParsedData> data, std::string& entryName, YAML::Node& node, std::string* replacement) override;
+    };
+
+    class UnkSpawnDataCodeExporter : public BaseExporter {
+        ExportResult Export(std::ostream& write, std::shared_ptr<IParsedData> data, std::string& entryName, YAML::Node& node, std::string* replacement) override;
+    };
+
+    class UnkSpawnDataFactory : public BaseFactory {
+    public:
+        std::optional<std::shared_ptr<IParsedData>> parse(std::vector<uint8_t>& buffer, YAML::Node& data) override;
+        std::optional<std::shared_ptr<IParsedData>> parse_modding(std::vector<uint8_t>& buffer, YAML::Node& data) override {
+            return std::nullopt;
+        }
+        inline std::unordered_map<ExportType, std::shared_ptr<BaseExporter>> GetExporters() override {
+            return {
+                REGISTER(Code, UnkSpawnDataCodeExporter)
+                REGISTER(Header, UnkSpawnDataHeaderExporter)
+                REGISTER(Binary, UnkSpawnDataBinaryExporter)
+            };
+        }
+        bool SupportModdedAssets() override { return false; }
+    };
+}
\ No newline at end of file