Trajectory Factory

src/Companion.cpp

@@ -37,6 +37,7 @@
 #include "factories/sm64/MacroFactory.h"
 #include "factories/sm64/MovtexFactory.h"
 #include "factories/sm64/MovtexQuadFactory.h"
+#include "factories/sm64/TrajectoryFactory.h"
 
 #include "factories/mk64/CourseVtx.h"
 #include "factories/mk64/Waypoints.h"
@@ -97,6 +98,7 @@ void Companion::Init(const ExportType type) {
     this->RegisterFactory("SM64:MACRO", std::make_shared<SM64::MacroFactory>());
     this->RegisterFactory("SM64:MOVTEX_QUAD", std::make_shared<SM64::MovtexQuadFactory>());
     this->RegisterFactory("SM64:MOVTEX", std::make_shared<SM64::MovtexFactory>());
+    this->RegisterFactory("SM64:TRAJECTORY", std::make_shared<SM64::TrajectoryFactory>());
 
     // MK64 specific
     this->RegisterFactory("MK64:COURSE_VTX", std::make_shared<MK64::CourseVtxFactory>());

src/factories/ResourceType.h

@@ -32,6 +32,7 @@ enum class ResourceType {
     MacroObject = 0x4D41434F,  // MACO
     Movtex = 0x4D4F5654,       // MOVT
     MovtexQuad = 0x4D4F5651,   // MOVQ
+    Trajectory = 0x5452414A,   // TRAJ
 
     // MK64
     CourseVertex = 0x43565458, // CVTX

src/factories/sm64/TracjetoryFactory.cpp

@@ -0,0 +1,81 @@
+#include "TrajectoryFactory.h"
+#include "spdlog/spdlog.h"
+
+#include "Companion.h"
+#include "utils/Decompressor.h"
+#include "utils/TorchUtils.h"
+#include <regex>
+
+ExportResult SM64::TrajectoryHeaderExporter::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 char " << symbol << "[] = \"__OTR__" << (*replacement) << "\";\n\n";
+        return std::nullopt;
+    }
+
+    write << "extern Trajectory " << symbol << "[];\n";
+    return std::nullopt;
+}
+
+ExportResult SM64::TrajectoryCodeExporter::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);
+    const auto offset = GetSafeNode<uint32_t>(node, "offset");
+
+    auto trajectoryData = std::static_pointer_cast<SM64::TrajectoryData>(raw)->mTrajectoryData;
+
+    write << "const Trajectory " << symbol << "[] = {\n";
+
+    for (auto &object : trajectoryData) {
+        write << fourSpaceTab;
+        write << "TRAJECTORY_POS(";
+        write << object.trajId << ", " << object.posX << ", " << object.posY << ", " << object.posZ << "),\n";
+    }
+
+    write << fourSpaceTab << "TRAJECTORY_END(),";
+
+    write << "\n};\n";
+
+    size_t size = (trajectoryData.size()) * sizeof(Trajectory) + 1;
+
+    return offset + size;
+}
+
+ExportResult SM64::TrajectoryBinaryExporter::Export(std::ostream &write, std::shared_ptr<IParsedData> raw, std::string& entryName, YAML::Node &node, std::string* replacement ) {
+    auto writer = LUS::BinaryWriter();
+    auto trajectoryData = std::static_pointer_cast<SM64::TrajectoryData>(raw)->mTrajectoryData;
+
+    WriteHeader(writer, LUS::ResourceType::Trajectory, 0);
+
+    writer.Write((uint32_t)trajectoryData.size());
+    
+    for (auto &trajectory : trajectoryData) {
+        writer.Write(trajectory.trajId);
+        writer.Write(trajectory.posX);
+        writer.Write(trajectory.posY);
+        writer.Write(trajectory.posZ);
+    }
+
+    writer.Finish(write);
+    return std::nullopt;
+}
+
+std::optional<std::shared_ptr<IParsedData>> SM64::TrajectoryFactory::parse(std::vector<uint8_t>& buffer, YAML::Node& node) {
+    std::vector<Trajectory> trajectoryData;
+    auto [_, segment] = Decompressor::AutoDecode(node, buffer);
+    LUS::BinaryReader reader(segment.data, segment.size);
+    reader.SetEndianness(LUS::Endianness::Big);
+
+    while (true) {
+        auto trajId = reader.ReadInt16();
+        if (trajId == -1) {
+            break;
+        }
+        auto posX = reader.ReadInt16();
+        auto posY = reader.ReadInt16();
+        auto posZ = reader.ReadInt16();
+        trajectoryData.emplace_back(trajId, posX, posY, posZ);
+    }
+
+    return std::make_shared<SM64::TrajectoryData>(trajectoryData);
+}

src/factories/sm64/TrajectoryFactory.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include "factories/BaseFactory.h"
+#include "types/Vec3D.h"
+
+namespace SM64 {
+
+struct Trajectory {
+    int16_t trajId;
+    int16_t posX;
+    int16_t posY;
+    int16_t posZ;
+    Trajectory(int16_t trajId, int16_t posX, int16_t posY, int16_t posZ) : trajId(trajId), posX(posX), posY(posY), posZ(posZ) {}
+};
+
+class TrajectoryData : public IParsedData {
+public:
+    std::vector<Trajectory> mTrajectoryData;
+
+    TrajectoryData(std::vector<Trajectory> trajectoryData) : mTrajectoryData(std::move(trajectoryData)) {}
+};
+
+class TrajectoryHeaderExporter : public BaseExporter {
+    ExportResult Export(std::ostream& write, std::shared_ptr<IParsedData> data, std::string& entryName, YAML::Node& node, std::string* replacement) override;
+};
+
+class TrajectoryBinaryExporter : public BaseExporter {
+    ExportResult Export(std::ostream& write, std::shared_ptr<IParsedData> data, std::string& entryName, YAML::Node& node, std::string* replacement) override;
+};
+
+class TrajectoryCodeExporter : public BaseExporter {
+    ExportResult Export(std::ostream& write, std::shared_ptr<IParsedData> data, std::string& entryName, YAML::Node& node, std::string* replacement) override;
+};
+
+class TrajectoryFactory : public BaseFactory {
+public:
+    std::optional<std::shared_ptr<IParsedData>> parse(std::vector<uint8_t>& buffer, YAML::Node& data) override;
+    inline std::unordered_map<ExportType, std::shared_ptr<BaseExporter>> GetExporters() override {
+        return {
+            REGISTER(Code, TrajectoryCodeExporter)
+            REGISTER(Header, TrajectoryHeaderExporter)
+            REGISTER(Binary, TrajectoryBinaryExporter)
+        };
+    }
+};
+}