Fixed possible conflicts with LUS

TemplateFactory.cpp

@@ -35,7 +35,7 @@ ExportResult TypeBinaryExporter::Export(std::ostream &write, std::shared_ptr<IPa
 std::optional<std::shared_ptr<IParsedData>> TypeFactory::parse(std::vector<uint8_t>& buffer, YAML::Node& node) {
     auto [root, segment] = Decompressor::AutoDecode(node, buffer, 0x1000);
     LUS::BinaryReader reader(segment.data, segment.size);
-    reader.SetEndianness(LUS::Endianness::Big);
+    reader.SetEndianness(Torch::Endianness::Big);
 
     return std::make_shared<TypeData>();
 }

lib/binarytools/BinaryReader.cpp

@@ -24,11 +24,11 @@ void LUS::BinaryReader::Close() {
     mStream->Close();
 }
 
-void LUS::BinaryReader::SetEndianness(Endianness endianness) {
+void LUS::BinaryReader::SetEndianness(Torch::Endianness endianness) {
     this->mEndianness = endianness;
 }
 
-LUS::Endianness LUS::BinaryReader::GetEndianness() const {
+Torch::Endianness LUS::BinaryReader::GetEndianness() const {
     return mEndianness;
 }
 
@@ -59,7 +59,7 @@ int8_t LUS::BinaryReader::ReadInt8() {
 int16_t LUS::BinaryReader::ReadInt16() {
     int16_t result = 0;
     mStream->Read((char*)&result, sizeof(int16_t));
-    if (mEndianness != Endianness::Native) {
+    if (mEndianness != Torch::Endianness::Native) {
         result = BSWAP16(result);
     }
     return result;
@@ -70,7 +70,7 @@ int32_t LUS::BinaryReader::ReadInt32() {
 
     mStream->Read((char*)&result, sizeof(int32_t));
 
-    if (mEndianness != Endianness::Native) {
+    if (mEndianness != Torch::Endianness::Native) {
         result = BSWAP32(result);
     }
 
@@ -86,7 +86,7 @@ uint16_t LUS::BinaryReader::ReadUInt16() {
 
     mStream->Read((char*)&result, sizeof(uint16_t));
 
-    if (mEndianness != Endianness::Native) {
+    if (mEndianness != Torch::Endianness::Native) {
         result = BSWAP16(result);
     }
 
@@ -98,7 +98,7 @@ uint32_t LUS::BinaryReader::ReadUInt32() {
 
     mStream->Read((char*)&result, sizeof(uint32_t));
 
-    if (mEndianness != Endianness::Native) {
+    if (mEndianness != Torch::Endianness::Native) {
         result = BSWAP32(result);
     }
 
@@ -110,7 +110,7 @@ uint64_t LUS::BinaryReader::ReadUInt64() {
 
     mStream->Read((char*)&result, sizeof(uint64_t));
 
-    if (mEndianness != Endianness::Native) {
+    if (mEndianness != Torch::Endianness::Native) {
         result = BSWAP64(result);
     }
 
@@ -121,7 +121,7 @@ unsigned short LUS::BinaryReader::ReadUShort() {
     unsigned short result = 0;
     mStream->Read((char*)&result, sizeof(unsigned short));
 
-    if (mEndianness != Endianness::Native) {
+    if (mEndianness != Torch::Endianness::Native) {
         result = BSWAP16(result);
     }
 
@@ -132,7 +132,7 @@ short LUS::BinaryReader::ReadShort() {
     short result = 0;
     mStream->Read((char*)&result, sizeof(short));
 
-    if (mEndianness != Endianness::Native) {
+    if (mEndianness != Torch::Endianness::Native) {
         result = BSWAP16(result);
     }
 
@@ -144,7 +144,7 @@ float LUS::BinaryReader::ReadFloat() {
 
     mStream->Read((char*)&result, sizeof(float));
 
-    if (mEndianness != Endianness::Native) {
+    if (mEndianness != Torch::Endianness::Native) {
         float tmp;
         char* dst = (char*)&tmp;
         char* src = (char*)&result;
@@ -167,7 +167,7 @@ double LUS::BinaryReader::ReadDouble() {
 
     mStream->Read((char*)&result, sizeof(double));
 
-    if (mEndianness != Endianness::Native) {
+    if (mEndianness != Torch::Endianness::Native) {
         double tmp;
         char* dst = (char*)&tmp;
         char* src = (char*)&result;

lib/binarytools/BinaryReader.h

@@ -3,8 +3,8 @@
 #include <string>
 #include <memory>
 #include <vector>
-#include "endianness.h"
-#include "Stream.h"
+#include "lib/binarytools/endianness.h"
+#include "lib/binarytools/Stream.h"
 
 class BinaryReader;
 
@@ -19,8 +19,8 @@ class BinaryReader {
 
     void Close();
 
-    void SetEndianness(Endianness endianness);
-    Endianness GetEndianness() const;
+    void SetEndianness(Torch::Endianness endianness);
+    Torch::Endianness GetEndianness() const;
 
     void Seek(int32_t offset, SeekOffsetType seekType);
     uint32_t GetBaseAddress();
@@ -47,6 +47,6 @@ class BinaryReader {
 
   protected:
     std::shared_ptr<Stream> mStream;
-    Endianness mEndianness = Endianness::Native;
+    Torch::Endianness mEndianness = Torch::Endianness::Native;
 };
 } // namespace LUS

lib/binarytools/BinaryWriter.cpp

@@ -14,7 +14,7 @@ LUS::BinaryWriter::BinaryWriter(std::shared_ptr<Stream> nStream) {
     mStream = nStream;
 }
 
-void LUS::BinaryWriter::SetEndianness(Endianness endianness) {
+void LUS::BinaryWriter::SetEndianness(Torch::Endianness endianness) {
     this->mEndianness = endianness;
 }
 
@@ -47,7 +47,7 @@ void LUS::BinaryWriter::Write(uint8_t value) {
 }
 
 void LUS::BinaryWriter::Write(int16_t value) {
-    if (mEndianness != Endianness::Native) {
+    if (mEndianness != Torch::Endianness::Native) {
         value = BSWAP16(value);
     }
 
@@ -55,7 +55,7 @@ void LUS::BinaryWriter::Write(int16_t value) {
 }
 
 void LUS::BinaryWriter::Write(uint16_t value) {
-    if (mEndianness != Endianness::Native) {
+    if (mEndianness != Torch::Endianness::Native) {
         value = BSWAP16(value);
     }
 
@@ -63,7 +63,7 @@ void LUS::BinaryWriter::Write(uint16_t value) {
 }
 
 void LUS::BinaryWriter::Write(int32_t value) {
-    if (mEndianness != Endianness::Native) {
+    if (mEndianness != Torch::Endianness::Native) {
         value = BSWAP32(value);
     }
 
@@ -76,7 +76,7 @@ void LUS::BinaryWriter::Write(int32_t valueA, int32_t valueB) {
 }
 
 void LUS::BinaryWriter::Write(uint32_t value) {
-    if (mEndianness != Endianness::Native) {
+    if (mEndianness != Torch::Endianness::Native) {
         value = BSWAP32(value);
     }
 
@@ -84,7 +84,7 @@ void LUS::BinaryWriter::Write(uint32_t value) {
 }
 
 void LUS::BinaryWriter::Write(int64_t value) {
-    if (mEndianness != Endianness::Native) {
+    if (mEndianness != Torch::Endianness::Native) {
         value = BSWAP64(value);
     }
 
@@ -92,7 +92,7 @@ void LUS::BinaryWriter::Write(int64_t value) {
 }
 
 void LUS::BinaryWriter::Write(uint64_t value) {
-    if (mEndianness != Endianness::Native) {
+    if (mEndianness != Torch::Endianness::Native) {
         value = BSWAP64(value);
     }
 
@@ -100,7 +100,7 @@ void LUS::BinaryWriter::Write(uint64_t value) {
 }
 
 void LUS::BinaryWriter::Write(float value) {
-    if (mEndianness != Endianness::Native) {
+    if (mEndianness != Torch::Endianness::Native) {
         float tmp;
         char* dst = (char*)&tmp;
         char* src = (char*)&value;
@@ -115,7 +115,7 @@ void LUS::BinaryWriter::Write(float value) {
 }
 
 void LUS::BinaryWriter::Write(double value) {
-    if (mEndianness != Endianness::Native) {
+    if (mEndianness != Torch::Endianness::Native) {
         double tmp;
         char* dst = (char*)&tmp;
         char* src = (char*)&value;

lib/binarytools/BinaryWriter.h

@@ -4,8 +4,8 @@
 #include <memory>
 #include <string>
 #include <vector>
-#include "endianness.h"
-#include "Stream.h"
+#include "lib/binarytools/endianness.h"
+#include "lib/binarytools/Stream.h"
 
 namespace LUS {
 class BinaryWriter {
@@ -14,7 +14,7 @@ class BinaryWriter {
     BinaryWriter(Stream* nStream);
     BinaryWriter(std::shared_ptr<Stream> nStream);
 
-    void SetEndianness(Endianness endianness);
+    void SetEndianness(Torch::Endianness endianness);
 
     std::shared_ptr<Stream> GetStream();
     uint64_t GetBaseAddress();
@@ -43,7 +43,7 @@ class BinaryWriter {
 
 protected:
     std::shared_ptr<Stream> mStream;
-    Endianness mEndianness = Endianness::Native;
+    Torch::Endianness mEndianness = Torch::Endianness::Native;
 
 };
 } // namespace LUS

lib/binarytools/endianness.h

@@ -1,8 +1,7 @@
-#ifndef ENDIANESS_H
-#define ENDIANESS_H
+#pragma once
 
 #ifdef __cplusplus
-namespace LUS {
+namespace Torch {
 enum class Endianness {
     Little = 0,
     Big = 1,
@@ -83,6 +82,4 @@ enum class Endianness {
 #define LE16SWAP_CONST(x) (x)
 #define LE32SWAP_CONST(x) (x)
 #define LE64SWAP_CONST(x) (x)
-#endif
-
-#endif
+#endif

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