exporters

src/Companion.cpp

@@ -163,6 +163,8 @@ void Companion::ParseEnums(std::string& header) {
 void Companion::ExtractNode(YAML::Node& node, std::string& name, SWrapper* binary) {
     std::ostringstream stream;
 
+    this->gCurrentWrapper = binary;
+
     auto type = GetSafeNode<std::string>(node, "type");
     std::transform(type.begin(), type.end(), type.begin(), ::toupper);
 

src/Companion.h

@@ -118,6 +118,7 @@ public:
     std::string NormalizeAsset(const std::string& name) const;
 
     TorchConfig& GetConfig() { return this->gConfig; }
+    SWrapper* GetCurrentWrapper() { return this->gCurrentWrapper; }
 
     std::optional<std::tuple<std::string, YAML::Node>> RegisterAsset(const std::string& name, YAML::Node& node);
     std::optional<YAML::Node> AddAsset(YAML::Node asset);
@@ -132,6 +133,7 @@ private:
     YAML::Node gHashNode;
     std::shared_ptr<N64::Cartridge> gCartridge;
     std::unordered_map<std::string, std::unordered_map<int32_t, std::string>> gEnums;
+    SWrapper* gCurrentWrapper;
 
     // Temporal Variables
     std::string gCurrentFile;

src/factories/ResourceType.h

@@ -19,6 +19,8 @@ enum class ResourceType {
     Sample = 0x41554643,       // AIFC
     Sequence = 0x53455143,     // SEQC
     Lights = 0x46669697,       // LGTS
+    Vec3f = 0x56433346,        // VC3F
+    Vec3s = 0x56433353,        // VC3S
 
     // SM64
     Anim = 0x414E494D,         // ANIM
@@ -36,10 +38,14 @@ enum class ResourceType {
 
     // SF64
     AnimData = 0x414E494D,     // ANIM
-    Message = 0x4D53474C,      // MSG
+    ColPoly = 0x43504C59,      // CPLY
+    EnvSettings = 0x454E5653,  // ENVS
+    Limb = 0x4C494D42,         // LIMB
+    Message = 0x4D534720,      // MSG
     MessageTable = 0x4D534754, // MSGT
     Skeleton = 0x534B454C,     // SKEL
     Script = 0x53435250,       // SCRP
+    ScriptCmd = 0x53434D44,    // SCMD
     Hitbox = 0x48544258,       // HTBX
     ObjectInit = 0x4F42494E,   // OBIN
 };

src/factories/Vec3fFactory.cpp

@@ -59,6 +59,20 @@ ExportResult Vec3fCodeExporter::Export(std::ostream &write, std::shared_ptr<IPar
 }
 
 ExportResult Vec3fBinaryExporter::Export(std::ostream &write, std::shared_ptr<IParsedData> raw, std::string& entryName, YAML::Node &node, std::string* replacement ) {
+    auto writer = LUS::BinaryWriter();
+    auto vecData = std::static_pointer_cast<Vec3fData>(raw);
+
+    WriteHeader(writer, LUS::ResourceType::Vec3f, 0);
+    writer.Write((uint32_t) vecData->mVecs.size());
+
+    for(Vec3f v : vecData->mVecs) {
+        auto [x, y, z] = v;
+        writer.Write(x);
+        writer.Write(y);
+        writer.Write(z);
+    }
+    
+    writer.Finish(write);
     return std::nullopt;
 }
 

src/factories/Vec3sFactory.cpp

@@ -57,6 +57,20 @@ ExportResult Vec3sCodeExporter::Export(std::ostream &write, std::shared_ptr<IPar
 }
 
 ExportResult Vec3sBinaryExporter::Export(std::ostream &write, std::shared_ptr<IParsedData> raw, std::string& entryName, YAML::Node &node, std::string* replacement ) {
+    auto writer = LUS::BinaryWriter();
+    auto vecData = std::static_pointer_cast<Vec3sData>(raw);
+
+    WriteHeader(writer, LUS::ResourceType::Vec3s, 0);
+    writer.Write((uint32_t) vecData->mVecs.size());
+
+    for(Vec3s v : vecData->mVecs) {
+        auto [x, y, z] = v;
+        writer.Write(x);
+        writer.Write(y);
+        writer.Write(z);
+    }
+
+    writer.Finish(write);
     return std::nullopt;
 }
 

src/factories/sf64/ColPolyFactory.cpp

@@ -63,6 +63,30 @@ ExportResult SF64::ColPolyCodeExporter::Export(std::ostream &write, std::shared_
 }
 
 ExportResult SF64::ColPolyBinaryExporter::Export(std::ostream &write, std::shared_ptr<IParsedData> raw, std::string& entryName, YAML::Node &node, std::string* replacement ) {
+    auto writer = LUS::BinaryWriter();
+    auto colpolys = std::static_pointer_cast<SF64::ColPolyData>(raw);
+
+    WriteHeader(writer, LUS::ResourceType::ColPoly, 0);
+
+    writer.Write((uint32_t) colpolys->mPolys.size());
+
+    for(auto &poly : colpolys->mPolys) {
+        writer.Write(poly.tri.x);
+        writer.Write(poly.tri.y);
+        writer.Write(poly.tri.z);
+        if (poly.unk_06 != 0) {
+            SPDLOG_ERROR("SF64:COLPOLY error: Nonzero value found in padding");
+        }
+        writer.Write(poly.norm.x);
+        writer.Write(poly.norm.y);
+        writer.Write(poly.norm.z);
+        if (poly.unk_0E != 0) {
+            SPDLOG_ERROR("SF64:COLPOLY error: Nonzero value found in padding");
+        }
+        writer.Write(poly.dist);
+    }
+
+    writer.Finish(write);
     return std::nullopt;
 }
 

src/factories/sf64/EnvSettingsFactory.cpp

@@ -54,6 +54,31 @@ ExportResult SF64::EnvSettingsCodeExporter::Export(std::ostream &write, std::sha
 }
 
 ExportResult SF64::EnvSettingsBinaryExporter::Export(std::ostream &write, std::shared_ptr<IParsedData> raw, std::string& entryName, YAML::Node &node, std::string* replacement ) {
+    auto writer = LUS::BinaryWriter();
+    auto envSettings = std::static_pointer_cast<SF64::EnvSettingsData>(raw);
+
+    WriteHeader(writer, LUS::ResourceType::EnvSettings, 0);
+
+    writer.Write(envSettings->mType);
+    writer.Write(envSettings->mUnk_04);
+    writer.Write(envSettings->mBgColor);
+    writer.Write(envSettings->mSeqId);
+    writer.Write(envSettings->mFogR);
+    writer.Write(envSettings->mFogG);
+    writer.Write(envSettings->mFogB);
+    writer.Write(envSettings->mFogN);
+    writer.Write(envSettings->mFogF);
+    writer.Write(envSettings->mUnk_20.x);
+    writer.Write(envSettings->mUnk_20.y);
+    writer.Write(envSettings->mUnk_20.z);
+    writer.Write(envSettings->mLightR);
+    writer.Write(envSettings->mLightG);
+    writer.Write(envSettings->mLightB);
+    writer.Write(envSettings->mAmbR);
+    writer.Write(envSettings->mAmbG);
+    writer.Write(envSettings->mAmbB);
+
+    writer.Finish(write);
     return std::nullopt;
 }
 

src/factories/sf64/ScriptFactory.cpp

@@ -5,6 +5,8 @@
 #include "utils/Decompressor.h"
 #include "utils/TorchUtils.h"
 
+#include "storm/SWrapper.h"
+
 SF64::ScriptData::ScriptData(std::vector<uint32_t> ptrs, std::vector<uint16_t> cmds, std::map<uint32_t, int> sizeMap, uint32_t ptrsStart, uint32_t cmdsStart): mPtrs(ptrs), mCmds(cmds), mSizeMap(sizeMap), mPtrsStart(ptrsStart), mCmdsStart(cmdsStart) {
 
 }
@@ -138,6 +140,54 @@ ExportResult SF64::ScriptCodeExporter::Export(std::ostream &write, std::shared_p
 }
 
 ExportResult SF64::ScriptBinaryExporter::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);
+    auto scriptWriter = LUS::BinaryWriter();
+    auto script = std::static_pointer_cast<SF64::ScriptData>(raw);
+    auto sortedPtrs = script->mPtrs;
+    std::sort(sortedPtrs.begin(), sortedPtrs.end());
+    uint32_t ptrCount = 0;
+    uint32_t cmdIndex = 0;
+    std::unordered_map<uint32_t, uint64_t> ptrMap;
+
+    // Export Commands and Populate Hashes Map
+    for (auto ptr : sortedPtrs) {
+        auto wrapper = Companion::Instance->GetCurrentWrapper();
+        std::ostringstream stream;
+        stream.str("");
+        stream.clear();
+
+        auto cmdWriter = LUS::BinaryWriter();
+        WriteHeader(cmdWriter, LUS::ResourceType::ScriptCmd, 0);
+
+        auto cmdCount = script->mSizeMap.at(ptr) / 2;
+        cmdWriter.Write((uint32_t) cmdCount);
+
+        // Writing in pairs for readability
+        for (uint32_t i = 0; i < cmdCount; ++i) {
+            cmdWriter.Write(script->mCmds.at(cmdIndex++));
+            cmdWriter.Write(script->mCmds.at(cmdIndex++));
+        }
+
+        cmdWriter.Finish(stream);
+
+        auto data = stream.str();
+        wrapper->CreateFile(entryName + "_cmd_" + std::to_string(ptrCount), std::vector(data.begin(), data.end()));
+
+        std::ostringstream cmdName;
+        cmdName << symbol << "_cmd_" << std::dec << ptrCount;
+        ptrMap[ptr] = CRC64(cmdName.str().c_str());
+        ptrCount++;
+    }
+
+    // Export Script
+    WriteHeader(scriptWriter, LUS::ResourceType::Script, 0);
+    scriptWriter.Write((uint32_t) script->mPtrs.size());
+    for (auto &ptr : script->mPtrs) {
+        scriptWriter.Write(ptrMap.at(ptr));
+    }
+
+    scriptWriter.Finish(write);
+
     return std::nullopt;
 }
 

src/factories/sf64/SkeletonFactory.cpp

@@ -5,6 +5,8 @@
 #include "utils/Decompressor.h"
 #include "utils/TorchUtils.h"
 
+#include "storm/SWrapper.h"
+
 #define NUM(x, w) std::dec << std::setfill(' ') << std::setw(w) << x
 // #define NUM_JOINT(x) std::dec << std::setfill(' ') << std::setw(5) << x
 #define FLOAT(x, w, p) std::dec << std::setfill(' ') << std::setw(w) << std::fixed << std::setprecision(p) << x
@@ -31,7 +33,7 @@ ExportResult SF64::SkeletonCodeExporter::Export(std::ostream &write, std::shared
     auto skeleton = std::static_pointer_cast<SF64::SkeletonData>(raw);
     auto limbs = skeleton->mSkeleton;
     std::sort(limbs.begin(), limbs.end(), [](SF64::LimbData a, SF64::LimbData b) {return a.mAddr < b.mAddr;});
-    std::map<uint32_t, std::string> limbDict;
+    std::unordered_map<uint32_t, std::string> limbDict;
 
     limbDict[0] = "NULL";
     for(SF64::LimbData limb : limbs) {
@@ -87,12 +89,72 @@ ExportResult SF64::SkeletonCodeExporter::Export(std::ostream &write, std::shared
 }
 
 ExportResult SF64::SkeletonBinaryExporter::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);
+    auto skeletonWriter = LUS::BinaryWriter();
+    auto skeleton = std::static_pointer_cast<SF64::SkeletonData>(raw);
+    auto limbs = skeleton->mSkeleton;
+    std::unordered_map<uint32_t, uint64_t> limbDict;
+
+    // Populate map of limbs with hashes
+    for (auto &limb : limbs) {
+        std::ostringstream limbDefaultName;
+        limbDefaultName << symbol << "_limb_" << std::dec << limb.mIndex;
+        limbDict[limb.mAddr] = CRC64(limbDefaultName.str().c_str());
+    }
+
+    // Export Each Limb
+    for (auto &limb : limbs) {
+        auto wrapper = Companion::Instance->GetCurrentWrapper();
+        std::ostringstream stream;
+        stream.str("");
+        stream.clear();
+
+        auto limbWriter = LUS::BinaryWriter();
+        WriteHeader(limbWriter, LUS::ResourceType::Limb, 0);
+        uint64_t hash = 0;
+        if (limb.mDList != 0) {
+            auto dec = Companion::Instance->GetNodeByAddr(limb.mDList);
+            if (dec.has_value()){
+                hash = CRC64(std::get<0>(dec.value()).c_str());
+                SPDLOG_INFO("Found display list: 0x{:X} Hash: 0x{:X} Path: {}", limb.mDList, hash, std::get<0>(dec.value()));
+            } else {
+                SPDLOG_WARN("Could not find dlist at 0x{:X}", limb.mDList);
+            }
+        }
+        limbWriter.Write(hash);
+        auto [transX, transY, transZ] = limb.mTrans;
+        limbWriter.Write(transX);
+        limbWriter.Write(transY);
+        limbWriter.Write(transZ);
+        auto [rotX, rotY, rotZ] = limb.mRot;
+        limbWriter.Write(rotX);
+        limbWriter.Write(rotY);
+        limbWriter.Write(rotZ);
+        uint64_t sibling = (limb.mSibling != 0) ? limbDict.at(limb.mSibling) : 0;
+        limbWriter.Write(sibling);
+        uint64_t child = (limb.mChild != 0) ? limbDict.at(limb.mChild) : 0;
+        limbWriter.Write(child);
+        limbWriter.Finish(stream);
+
+        auto data = stream.str();
+        wrapper->CreateFile(entryName + "_limb_" + std::to_string(limb.mIndex), std::vector(data.begin(), data.end()));
+    }
+
+    // Export Skeleton
+    WriteHeader(skeletonWriter, LUS::ResourceType::Skeleton, 0);
+    skeletonWriter.Write((uint32_t) limbs.size());
+    for (auto &limb : limbs) {
+        skeletonWriter.Write(limbDict.at(limb.mAddr));
+    }
+
+    skeletonWriter.Finish(write);
+    
+    
     return std::nullopt;
 }
 
 std::optional<std::shared_ptr<IParsedData>> SF64::SkeletonFactory::parse(std::vector<uint8_t>& buffer, YAML::Node& node) {
     std::vector<SF64::LimbData> skeleton;
-    std::map<std::string, std::string> limbDict;
     auto [root, segment] = Decompressor::AutoDecode(node, buffer, 0x1000);
     LUS::BinaryReader reader(segment.data, segment.size);
     reader.SetEndianness(LUS::Endianness::Big);

src/factories/sf64/TriangleFactory.cpp

@@ -52,6 +52,20 @@ ExportResult SF64::TriangleCodeExporter::Export(std::ostream &write, std::shared
 }
 
 ExportResult SF64::TriangleBinaryExporter::Export(std::ostream &write, std::shared_ptr<IParsedData> raw, std::string& entryName, YAML::Node &node, std::string* replacement ) {
+    auto writer = LUS::BinaryWriter();
+    auto triData = std::static_pointer_cast<TriangleData>(raw);
+
+    WriteHeader(writer, LUS::ResourceType::Vec3s, 0);
+    writer.Write((uint32_t) triData->mTris.size());
+
+    for(Vec3s tri : triData->mTris) {
+        auto [x, y, z] = tri;
+        writer.Write(x);
+        writer.Write(y);
+        writer.Write(z);
+    }
+
+    writer.Finish(write);
     return std::nullopt;
 }