Fixed possible conflicts with LUS

src/Companion.cpp

@@ -958,9 +958,11 @@ void Companion::Process() {
     bool isDirectoryMode = config["mode"] && config["mode"].as<std::string>() == "directory";
 
     if(!isDirectoryMode) {
-        std::ifstream input( this->gRomPath, std::ios::binary );
-        this->gRomData = std::vector<uint8_t>( std::istreambuf_iterator( input ), {} );
-        input.close();
+        if(this->gRomPath.has_value()){
+            std::ifstream input( this->gRomPath.value(), std::ios::binary );
+            this->gRomData = std::vector<uint8_t>( std::istreambuf_iterator( input ), {} );
+            input.close();
+        }
 
         this->gCartridge = std::make_shared<N64::Cartridge>(this->gRomData);
         this->gCartridge->Initialize();
@@ -1103,7 +1105,6 @@ void Companion::Process() {
     SPDLOG_INFO("Starting Torch...");
 
     if(this->gConfig.parseMode == ParseMode::Default) {
-        SPDLOG_INFO("ROM: {}", this->gRomPath);
         SPDLOG_INFO("Game: {}", this->gCartridge->GetGameTitle());
         SPDLOG_INFO("CRC: {}", this->gCartridge->GetCRC());
         SPDLOG_INFO("Version: {}", this->gCartridge->GetVersion());
@@ -1120,8 +1121,8 @@ void Companion::Process() {
     this->gCurrentWrapper = wrapper;
 
     auto vWriter = LUS::BinaryWriter();
-    vWriter.SetEndianness(LUS::Endianness::Big);
-    vWriter.Write(static_cast<uint8_t>(LUS::Endianness::Big));
+    vWriter.SetEndianness(Torch::Endianness::Big);
+    vWriter.Write(static_cast<uint8_t>(Torch::Endianness::Big));
 
     if(this->gConfig.parseMode == ParseMode::Default) {
         vWriter.Write(this->gCartridge->GetCRC());
@@ -1261,7 +1262,7 @@ std::optional<std::shared_ptr<BaseFactory>> Companion::GetFactory(const std::str
 CompressionType Companion::GetCompressionType(std::vector<uint8_t>& buffer, const uint32_t offset) {
     if (offset) {
         LUS::BinaryReader reader((char*) buffer.data() + offset, sizeof(uint32_t));
-        reader.SetEndianness(LUS::Endianness::Big);
+        reader.SetEndianness(Torch::Endianness::Big);
 
         const std::string header = reader.ReadCString();
 

src/Companion.h

@@ -103,7 +103,15 @@ class Companion {
 public:
     static Companion* Instance;
 
-    explicit Companion(std::filesystem::path rom, const bool otr, const bool debug, const bool modding = false) : gRomPath(std::move(rom)), gCartridge(nullptr) {
+    explicit Companion(std::filesystem::path rom, const bool otr, const bool debug, const bool modding = false) : gCartridge(nullptr) {
+        this->gRomPath = rom;
+        this->gConfig.otrMode = otr;
+        this->gConfig.debug = debug;
+        this->gConfig.modding = modding;
+    }
+
+    explicit Companion(std::vector<uint8_t> rom, const bool otr, const bool debug, const bool modding = false) : gCartridge(nullptr) {
+        this->gRomData = rom;
         this->gConfig.otrMode = otr;
         this->gConfig.debug = debug;
         this->gConfig.modding = modding;
@@ -160,7 +168,7 @@ private:
     std::string gCurrentHash;
     std::string gAssetPath;
     std::vector<uint8_t> gRomData;
-    std::filesystem::path gRomPath;
+    std::optional<std::filesystem::path> gRomPath;
     bool gNodeForceProcessing = false;
     bool gIndividualIncludes = false;
     YAML::Node gHashNode;

src/audio/AudioManager.cpp

@@ -70,7 +70,7 @@ void Bank::print() const {
 std::vector<Entry> AudioManager::parse_seq_file(std::vector<uint8_t>& buffer, uint32_t offset, bool isCTL){
     std::vector<Entry> entries;
     LUS::BinaryReader reader((char*) buffer.data(), buffer.size());
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
     reader.Seek(offset, LUS::SeekOffsetType::Start);
 
     uint16_t magic = reader.ReadUInt16();
@@ -100,7 +100,7 @@ std::vector<Entry> AudioManager::parse_seq_file(std::vector<uint8_t>& buffer, ui
 
 CTLHeader AudioManager::parse_ctl_header(std::vector<uint8_t>& data){
     LUS::BinaryReader reader((char*) data.data(), data.size());
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
 
     CTLHeader header = { reader.ReadUInt32(), reader.ReadUInt32(), reader.ReadUInt32() };
 
@@ -268,7 +268,7 @@ Bank AudioManager::parse_ctl(CTLHeader header, std::vector<uint8_t> data, Sample
 
 std::optional<AudioBankSound> AudioManager::parse_sound(std::vector<uint8_t> data) {
     LUS::BinaryReader reader((char*) data.data(), data.size());
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
 
     uint32_t addr = reader.ReadUInt32();
     float tuning = reader.ReadFloat();
@@ -286,7 +286,7 @@ std::optional<AudioBankSound> AudioManager::parse_sound(std::vector<uint8_t> dat
 
 Drum AudioManager::parse_drum(std::vector<uint8_t>& data, uint32_t addr) {
     LUS::BinaryReader reader((char*) data.data(), data.size());
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
     std::string name = gen_name("drum");
 
     uint8_t releaseRate = reader.ReadInt8();
@@ -331,7 +331,7 @@ Instrument AudioManager::parse_inst(std::vector<uint8_t>& data, uint32_t addr) {
 
 AdpcmLoop AudioManager::parse_loop(uint32_t addr, std::vector<uint8_t>& bankData){
     LUS::BinaryReader reader((char*) bankData.data(), bankData.size());
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
     reader.Seek(addr, LUS::SeekOffsetType::Start);
 
     std::optional<std::vector<int16_t>> state = std::nullopt;
@@ -352,7 +352,7 @@ AdpcmLoop AudioManager::parse_loop(uint32_t addr, std::vector<uint8_t>& bankData
 
 AdpcmBook AudioManager::parse_book(uint32_t addr, std::vector<uint8_t>& bankData){
     LUS::BinaryReader reader((char*) bankData.data(), bankData.size());
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
     reader.Seek(addr, LUS::SeekOffsetType::Start);
 
     int32_t order = reader.ReadInt32();
@@ -375,7 +375,7 @@ AdpcmBook AudioManager::parse_book(uint32_t addr, std::vector<uint8_t>& bankData
 
 AudioBankSample* AudioManager::parse_sample(std::vector<uint8_t>& data, std::vector<uint8_t>& bankData, SampleBank* sampleBank){
     LUS::BinaryReader reader((char*) data.data(), data.size());
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
 
     uint32_t zero = reader.ReadUInt32();
     uint32_t addr = reader.ReadUInt32();
@@ -397,7 +397,7 @@ AudioBankSample* AudioManager::parse_sample(std::vector<uint8_t>& data, std::vec
 std::vector<AdsrEnvelope> AudioManager::parse_envelope(uint32_t addr, std::vector<uint8_t>& dataBank){
     std::vector<AdsrEnvelope> entries;
     LUS::BinaryReader reader((char*) dataBank.data(), dataBank.size());
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
 
     while(true){
         reader.Seek(addr, LUS::SeekOffsetType::Start);
@@ -516,12 +516,12 @@ void serialize_f80(double num, LUS::BinaryWriter &writer) {
     { \
     out.Write((uint32_t) BSWAP32(section)); \
     LUS::BinaryWriter tmp = LUS::BinaryWriter(); \
-    tmp.SetEndianness(LUS::Endianness::Big);     \
+    tmp.SetEndianness(Torch::Endianness::Big);     \
 
 #define START_CUSTOM_SECTION(section) \
     {                                 \
     LUS::BinaryWriter tmp = LUS::BinaryWriter(); \
-    tmp.SetEndianness(LUS::Endianness::Big);     \
+    tmp.SetEndianness(Torch::Endianness::Big);     \
     out.Write((uint32_t) BSWAP32(AIFC::MagicValues::AAPL)); \
     tmp.Write(AIFC::MagicValues::stoc); \
     tmp.Write(section, false);                 \

src/factories/AssetArrayFactory.cpp

@@ -50,10 +50,10 @@ ExportResult AssetArrayBinaryExporter::Export(std::ostream &write, std::shared_p
     auto writer = LUS::BinaryWriter();
     auto data = std::static_pointer_cast<AssetArrayData>(raw);
 
-    WriteHeader(writer, LUS::ResourceType::AssetArray, 0);
+    WriteHeader(writer, Torch::ResourceType::AssetArray, 0);
 
     writer.Write((uint32_t)data->mPtrs.size());
-    
+
     for (auto ptr : data->mPtrs) {
         if (ptr == 0) {
             writer.Write((uint64_t)0);
@@ -81,7 +81,7 @@ std::optional<std::shared_ptr<IParsedData>> AssetArrayFactory::parse(std::vector
     const auto count = GetSafeNode<uint32_t>(node, "count");
     auto [_, segment] = Decompressor::AutoDecode(node, buffer);
     LUS::BinaryReader reader(segment.data, segment.size);
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
 
     for (uint32_t i = 0; i < count; ++i) {
         auto ptr = reader.ReadUInt32();

src/factories/BankFactory.cpp

@@ -5,7 +5,7 @@ ExportResult BankBinaryExporter::Export(std::ostream &write, std::shared_ptr<IPa
     auto writer = LUS::BinaryWriter();
     auto bank = std::static_pointer_cast<BankData>(raw);
 
-    WriteHeader(writer, LUS::ResourceType::Bank, 0);
+    WriteHeader(writer, Torch::ResourceType::Bank, 0);
     writer.Write(bank->mBankId);
     writer.Write(static_cast<uint32_t>(bank->mBank.insts.size()));
     for (auto& instrument : bank->mBank.insts) {

src/factories/BaseFactory.cpp

@@ -1,7 +1,7 @@
 #include "BaseFactory.h"
 
-void BaseExporter::WriteHeader(LUS::BinaryWriter &writer, LUS::ResourceType resType, int32_t version) {
-    writer.Write((int8_t)(LUS::Endianness::Native)); // 0x00 - Endianness
+void BaseExporter::WriteHeader(LUS::BinaryWriter &writer, Torch::ResourceType resType, int32_t version) {
+    writer.Write((int8_t)(Torch::Endianness::Native)); // 0x00 - Endianness
     writer.Write((int8_t)0); // 0x01 - Is Asset Custom
     writer.Write((int8_t)0); // 0x02 -
     writer.Write((int8_t)0); // 0x03

src/factories/BaseFactory.h

@@ -82,7 +82,7 @@ public:
 class BaseExporter {
 public:
     virtual ExportResult Export(std::ostream& write, std::shared_ptr<IParsedData> data, std::string& entryName, YAML::Node& node, std::string* replacement) = 0;
-    static void WriteHeader(LUS::BinaryWriter& write, LUS::ResourceType resType, int32_t version);
+    static void WriteHeader(LUS::BinaryWriter& write, Torch::ResourceType resType, int32_t version);
 };
 
 class BaseFactory {

src/factories/BlobFactory.cpp

@@ -48,7 +48,7 @@ ExportResult BlobBinaryExporter::Export(std::ostream &write, std::shared_ptr<IPa
     auto writer = LUS::BinaryWriter();
     auto data = std::static_pointer_cast<RawBuffer>(raw)->mBuffer;
 
-    WriteHeader(writer, LUS::ResourceType::Blob, 0);
+    WriteHeader(writer, Torch::ResourceType::Blob, 0);
     writer.Write((uint32_t) data.size());
     writer.Write((char*) data.data(), data.size());
     writer.Finish(write);

src/factories/DisplayListFactory.cpp

@@ -192,7 +192,7 @@ ExportResult DListBinaryExporter::Export(std::ostream &write, std::shared_ptr<IP
     auto cmds = std::static_pointer_cast<DListData>(raw)->mGfxs;
     auto writer = LUS::BinaryWriter();
 
-    WriteHeader(writer, LUS::ResourceType::DisplayList, 0);
+    WriteHeader(writer, Torch::ResourceType::DisplayList, 0);
 
     while (writer.GetBaseAddress() % 8 != 0)
         writer.Write(static_cast<int8_t>(0xFF));
@@ -385,7 +385,7 @@ std::optional<std::shared_ptr<IParsedData>> DListFactory::parse(std::vector<uint
 
     auto [_, segment] = Decompressor::AutoDecode(node, raw_buffer);
     LUS::BinaryReader reader(segment.data, segment.size);
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
 
     std::vector<uint32_t> gfxs;
     auto processing = true;

src/factories/FloatFactory.cpp

@@ -73,7 +73,7 @@ ExportResult FloatBinaryExporter::Export(std::ostream &write, std::shared_ptr<IP
     auto f = std::static_pointer_cast<FloatData>(raw);
     auto writer = LUS::BinaryWriter();
 
-    WriteHeader(writer, LUS::ResourceType::Float, 0);
+    WriteHeader(writer, Torch::ResourceType::Float, 0);
     writer.Write((uint32_t) f->mFloats.size());
     for(auto fl : f->mFloats) {
         writer.Write(fl);
@@ -89,7 +89,7 @@ std::optional<std::shared_ptr<IParsedData>> FloatFactory::parse(std::vector<uint
     auto [_, segment] = Decompressor::AutoDecode(node, buffer);
     LUS::BinaryReader reader(segment.data, count * sizeof(float));
 
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
     std::vector<float> floats;
 
     for(size_t i = 0; i < count; i++) {

src/factories/GenericArrayFactory.cpp

@@ -270,8 +270,8 @@ ExportResult ArrayBinaryExporter::Export(std::ostream &write, std::shared_ptr<IP
 
     ArrayType arrayType = arrayTypeMap.at(type);
 
-    WriteHeader(writer, LUS::ResourceType::GenericArray, 0);
-    
+    WriteHeader(writer, Torch::ResourceType::GenericArray, 0);
+
     writer.Write(static_cast<uint32_t>(arrayType));
     writer.Write((uint32_t) array->mData.size());
 
@@ -379,7 +379,7 @@ std::optional<std::shared_ptr<IParsedData>> GenericArrayFactory::parse(std::vect
 
     auto [root, segment] = Decompressor::AutoDecode(node, buffer, count * typeSize);
     LUS::BinaryReader reader(segment.data, segment.size);
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
 
     for (int i = 0; i < count; i++) {
         switch (arrayType) {

src/factories/LightsFactory.cpp

@@ -108,7 +108,7 @@ ExportResult LightsBinaryExporter::Export(std::ostream &write, std::shared_ptr<I
     auto writer = LUS::BinaryWriter();
     auto size = sizeof(light.l) / sizeof(LightRaw);
 
-    WriteHeader(writer, LUS::ResourceType::Lights, 0);
+    WriteHeader(writer, Torch::ResourceType::Lights, 0);
 
     writer.Write(reinterpret_cast<char*>(light.a.l.col), 3);
     writer.Write(reinterpret_cast<char*>(light.a.l.colc), 3);
@@ -130,7 +130,7 @@ std::optional<std::shared_ptr<IParsedData>> LightsFactory::parse(std::vector<uin
     auto [_, segment] = Decompressor::AutoDecode(node, buffer);
     LUS::BinaryReader reader(segment.data, sizeof(Lights1Raw));
 
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
     Lights1Raw lights;
     // Directional light
 

src/factories/MtxFactory.cpp

@@ -106,7 +106,7 @@ ExportResult MtxBinaryExporter::Export(std::ostream &write, std::shared_ptr<IPar
     auto mtx = std::static_pointer_cast<MtxData>(raw);
     auto writer = LUS::BinaryWriter();
 
-    WriteHeader(writer, LUS::ResourceType::Matrix, 0);
+    WriteHeader(writer, Torch::ResourceType::Matrix, 0);
     writer.Write((uint32_t) mtx->mMtxs.size());
     for(auto m : mtx->mMtxs) {
         writer.Write(m.mtx[0]);
@@ -137,7 +137,7 @@ std::optional<std::shared_ptr<IParsedData>> MtxFactory::parse(std::vector<uint8_
     auto [_, segment] = Decompressor::AutoDecode(node, buffer);
     LUS::BinaryReader reader(segment.data, 1 * sizeof(MtxRaw));
 
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
     std::vector<MtxRaw> matrix;
 
     #define FIXTOF(x)      ((float)((x) / 65536.0f))

src/factories/ResourceType.h

@@ -1,6 +1,6 @@
 #pragma once
 
-namespace LUS {
+namespace Torch {
 
 enum class ResourceType {
     // Not set

src/factories/SampleFactory.cpp

@@ -4,7 +4,7 @@ ExportResult SampleBinaryExporter::Export(std::ostream &write, std::shared_ptr<I
     auto writer = LUS::BinaryWriter();
     auto sample = std::static_pointer_cast<SampleData>(raw)->mSample;
 
-    WriteHeader(writer, LUS::ResourceType::Sample, 0);
+    WriteHeader(writer, Torch::ResourceType::Sample, 0);
     writer.Write(sample.loop.start);
     writer.Write(sample.loop.end);
     writer.Write(sample.loop.count);

src/factories/SequenceFactory.cpp

@@ -4,7 +4,7 @@ ExportResult SequenceBinaryExporter::Export(std::ostream &write, std::shared_ptr
     auto writer = LUS::BinaryWriter();
     const auto sequence = std::static_pointer_cast<SequenceData>(raw);
 
-    WriteHeader(writer, LUS::ResourceType::Sequence, 0);
+    WriteHeader(writer, Torch::ResourceType::Sequence, 0);
     writer.Write(sequence->mId);
     writer.Write(static_cast<uint32_t>(sequence->mBanks.size()));
     for (auto& bank : sequence->mBanks) {

src/factories/TextureFactory.cpp

@@ -220,7 +220,7 @@ ExportResult TextureBinaryExporter::Export(std::ostream &write, std::shared_ptr<
     auto texture = std::static_pointer_cast<TextureData>(raw);
     auto data = texture->mBuffer;
 
-    WriteHeader(writer, LUS::ResourceType::Texture, 0);
+    WriteHeader(writer, Torch::ResourceType::Texture, 0);
 
     if(texture->mFormat.type == TextureType::TLUT) {
         texture->mFormat.type = TextureType::RGBA16bpp;

src/factories/Vec3fFactory.cpp

@@ -62,7 +62,7 @@ ExportResult Vec3fBinaryExporter::Export(std::ostream &write, std::shared_ptr<IP
     auto writer = LUS::BinaryWriter();
     auto vecData = std::static_pointer_cast<Vec3fData>(raw);
 
-    WriteHeader(writer, LUS::ResourceType::Vec3f, 0);
+    WriteHeader(writer, Torch::ResourceType::Vec3f, 0);
     writer.Write((uint32_t) vecData->mVecs.size());
 
     for(Vec3f v : vecData->mVecs) {
@@ -81,7 +81,7 @@ std::optional<std::shared_ptr<IParsedData>> Vec3fFactory::parse(std::vector<uint
     const auto count = GetSafeNode<int>(node, "count");
     auto [root, segment] = Decompressor::AutoDecode(node, buffer, count * sizeof(Vec3f));
     LUS::BinaryReader reader(segment.data, segment.size);
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
 
     for(int i = 0; i < count; i++) {
         auto vx = reader.ReadFloat();

src/factories/Vec3sFactory.cpp

@@ -60,7 +60,7 @@ ExportResult Vec3sBinaryExporter::Export(std::ostream &write, std::shared_ptr<IP
     auto writer = LUS::BinaryWriter();
     auto vecData = std::static_pointer_cast<Vec3sData>(raw);
 
-    WriteHeader(writer, LUS::ResourceType::Vec3s, 0);
+    WriteHeader(writer, Torch::ResourceType::Vec3s, 0);
     writer.Write((uint32_t) vecData->mVecs.size());
 
     for(Vec3s v : vecData->mVecs) {
@@ -79,7 +79,7 @@ std::optional<std::shared_ptr<IParsedData>> Vec3sFactory::parse(std::vector<uint
     const auto count = GetSafeNode<int>(node, "count");
     auto [root, segment] = Decompressor::AutoDecode(node, buffer, count * sizeof(Vec3s));
     LUS::BinaryReader reader(segment.data, segment.size);
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
 
     for(int i = 0; i < count; i++) {
         auto vx = reader.ReadInt16();

src/factories/VtxFactory.cpp

@@ -125,7 +125,7 @@ ExportResult VtxBinaryExporter::Export(std::ostream &write, std::shared_ptr<IPar
     auto vtx = std::static_pointer_cast<VtxData>(raw);
     auto writer = LUS::BinaryWriter();
 
-    WriteHeader(writer, LUS::ResourceType::Vertex, 0);
+    WriteHeader(writer, Torch::ResourceType::Vertex, 0);
     writer.Write((uint32_t) vtx->mVtxs.size());
     for(auto v : vtx->mVtxs) {
         writer.Write(v.ob[0]);
@@ -150,7 +150,7 @@ std::optional<std::shared_ptr<IParsedData>> VtxFactory::parse(std::vector<uint8_
     auto [_, segment] = Decompressor::AutoDecode(node, buffer);
     LUS::BinaryReader reader(segment.data, count * sizeof(VtxRaw));
 
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
     std::vector<VtxRaw> vertices;
 
     for(size_t i = 0; i < count; i++) {