add UnkSpawData

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>());

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

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);
+}

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; }
+    };
+}