Cleanup (#49)

* Auto debug info generation and some cleanup

* Cleaned dry code from segments

* Fixed gCurrentCompressionType bss bs

24 files changed, 51 insertions, 189 deletions

diff --git a/src/Companion.cpp b/src/Companion.cpp
index 4b2b234..2dca649 100644
--- a/src/Companion.cpp
+++ b/src/Companion.cpp
@@ -250,13 +250,6 @@ void Companion::ExtractNode(YAML::Node& node, std::string& name, SWrapper* binar
             file.close();
             break;
         }
-        case ExportType::Code: {
-            endptr = exporter->get()->Export(stream, result.value(), name, node, &name);
-            if (this->IsDebug() && endptr.has_value() && endptr->index() == 0) {
-                stream << "// 0x" << std::hex << std::uppercase << std::get<0>(endptr.value()) << "\n\n";
-            }
-            break;
-        }
         default: {
             endptr = exporter->get()->Export(stream, result.value(), name, node, &name);
             break;
@@ -689,7 +682,7 @@ void Companion::Process() {
             } else {
                 const auto offset = assetNode["offset"].as<uint32_t>();
                 if(gCurrentFileOffset) {
-                    if (IS_SEGMENTED(offset) == false) {
+                    if (!IS_SEGMENTED(offset)) {
                         assetNode["offset"] = (gCurrentSegmentNumber << 24) | offset;
                     }
                 }
@@ -765,16 +758,18 @@ void Companion::Process() {
 
             for (size_t i = 0; i < entries.size(); i++) {
                 const auto result = entries[i];
-                stream << result.buffer;
+                const auto hasSize = result.endptr.has_value();
+                if (hasSize && this->IsDebug()) {
+                    stream << "// 0x" << std::hex << std::uppercase << ASSET_PTR(result.addr) << "\n";
+                }
 
-                if(i < entries.size() - 1 && this->gConfig.exporterType == ExportType::Code){
-                    auto endptr = result.endptr;
-                    if(!endptr.has_value()){
-                        continue;
-                    }
+                stream << result.buffer;
 
-#define ASSET_PTR(x) IS_SEGMENTED(x) ? SEGMENT_OFFSET(x) : x
+                if (hasSize && this->IsDebug()) {
+                    stream << "// 0x" << std::hex << std::uppercase << ASSET_PTR(result.endptr.value()) << "\n\n";
+                }
 
+                if(hasSize && i < entries.size() - 1 && this->gConfig.exporterType == ExportType::Code){
                     uint32_t startptr = ASSET_PTR(result.endptr.value());
                     uint32_t end = ASSET_PTR(entries[i + 1].addr);
 
diff --git a/src/Companion.h b/src/Companion.h
index abe8ce9..748efbb 100644
--- a/src/Companion.h
+++ b/src/Companion.h
@@ -135,7 +135,7 @@ private:
     uint32_t gCurrentFileOffset;
     uint32_t gCurrentSegmentNumber;
     std::optional<VRAMEntry> gCurrentVram;
-    CompressionType gCurrentCompressionType;
+    CompressionType gCurrentCompressionType = CompressionType::None;
     std::vector<Table> gTables;
     std::variant<std::vector<std::string>, std::string> gWriteOrder;
     std::unordered_map<std::string, std::shared_ptr<BaseFactory>> gFactories;
diff --git a/src/factories/BaseFactory.h b/src/factories/BaseFactory.h
index 1ec558f..1246c91 100644
--- a/src/factories/BaseFactory.h
+++ b/src/factories/BaseFactory.h
@@ -21,6 +21,7 @@
 #define SEGMENT_NUMBER(x) (((uint32_t)(x) >> 24) & 0xFF)
 // I would love to use 0x01000000, but the stupid compiler takes it as 0x01
 #define IS_SEGMENTED(x) (((uint32_t)(x) > 16777216) && (SEGMENT_NUMBER(x) < 0x20))
+#define ASSET_PTR(x) (IS_SEGMENTED(x) ? SEGMENT_OFFSET(x) : (x))
 
 #define tab "\t"
 #define fourSpaceTab "    "
diff --git a/src/factories/BlobFactory.cpp b/src/factories/BlobFactory.cpp
index db902c1..2b7f7fe 100644
--- a/src/factories/BlobFactory.cpp
+++ b/src/factories/BlobFactory.cpp
@@ -8,18 +8,7 @@ ExportResult BlobCodeExporter::Export(std::ostream &write, std::shared_ptr<IPars
     auto offset = GetSafeNode<uint32_t>(node, "offset");
     auto data = std::static_pointer_cast<RawBuffer>(raw)->mBuffer;
 
-    if (Companion::Instance->IsDebug()) {
-        if (IS_SEGMENTED(offset)) {
-            offset = SEGMENT_OFFSET(offset);
-        }
-        write << "// 0x" << std::hex << std::uppercase << offset << "\n";
-    }
-
-    if(node["ctype"]) {
-        write << node["ctype"].as<std::string>() << " " << symbol << "[] = {\n" << tab;
-    } else {
-        write << "u8 " << symbol << "[] = {\n" << tab;
-    }
+    write << GetSafeNode<std::string>(node, "ctype", "u8") << " " << symbol << "[] = {\n" << tab;
 
     for (int i = 0; i < data.size(); i++) {
         if ((i % 15 == 0) && i != 0) {
@@ -34,7 +23,7 @@ ExportResult BlobCodeExporter::Export(std::ostream &write, std::shared_ptr<IPars
         write << "// size: 0x" << std::hex << std::uppercase << data.size() << "\n";
     }
 
-    return (IS_SEGMENTED(offset) ? SEGMENT_OFFSET(offset) : offset) + data.size();
+    return offset + data.size();
 }
 
 ExportResult BlobBinaryExporter::Export(std::ostream &write, std::shared_ptr<IParsedData> raw, std::string& entryName, YAML::Node &node, std::string* replacement ) {
diff --git a/src/factories/DisplayListFactory.cpp b/src/factories/DisplayListFactory.cpp
index 88965ad..29c1bf9 100644
--- a/src/factories/DisplayListFactory.cpp
+++ b/src/factories/DisplayListFactory.cpp
@@ -114,13 +114,6 @@ ExportResult DListCodeExporter::Export(std::ostream &write, std::shared_ptr<IPar
     gfxd_lightsn_callback(GFXDOverride::Light);
     GFXDSetGBIVersion();
 
-    if (Companion::Instance->IsDebug()) {
-        if (IS_SEGMENTED(offset)) {
-            offset = SEGMENT_OFFSET(offset);
-        }
-        write << "// 0x" << std::hex << std::uppercase << offset << "\n";
-    }
-
     gfxd_puts(("Gfx " + symbol + "[] = {\n").c_str());
     gfxd_execute();
 
@@ -132,7 +125,7 @@ ExportResult DListCodeExporter::Export(std::ostream &write, std::shared_ptr<IPar
         write << "// count: " << std::to_string(sz / 8) << " Gfx\n";
     }
 
-    return (IS_SEGMENTED(offset) ? SEGMENT_OFFSET(offset) : offset) + sz;
+    return offset + sz;
 }
 
 void DebugDisplayList(uint32_t w0, uint32_t w1){
diff --git a/src/factories/TextureFactory.cpp b/src/factories/TextureFactory.cpp
index cdaef37..d30cb7b 100644
--- a/src/factories/TextureFactory.cpp
+++ b/src/factories/TextureFactory.cpp
@@ -162,15 +162,11 @@ ExportResult TextureCodeExporter::Export(std::ostream &write, std::shared_ptr<IP
 
         if(end == offset){
             write << "};\n";
-        }
-    } else {
-        if (Companion::Instance->IsDebug()) {
-            if (IS_SEGMENTED(offset)) {
-                offset = SEGMENT_OFFSET(offset);
+            if (Companion::Instance->IsDebug()) {
+                write << "// size: 0x" << std::hex << std::uppercase << ASSET_PTR((end - start) + data.size()) << "\n";
             }
-            write << "// 0x" << std::hex << std::uppercase << offset << "\n";
         }
-
+    } else {
         write << GetSafeNode<std::string>(node, "ctype", "static const u8") << " " << symbol  << "[] = {\n";
 
         write << tab << "#include \"" << Companion::Instance->GetOutputPath() + "/" << *replacement << ".inc.c\"\n";
@@ -181,7 +177,7 @@ ExportResult TextureCodeExporter::Export(std::ostream &write, std::shared_ptr<IP
             write << "// size: 0x" << std::hex << std::uppercase << sz << "\n";
         }
     }
-    return (IS_SEGMENTED(offset) ? SEGMENT_OFFSET(offset) : offset) + data.size();
+    return offset + data.size();
 }
 
 ExportResult TextureBinaryExporter::Export(std::ostream &write, std::shared_ptr<IParsedData> raw, std::string& entryName, YAML::Node &node, std::string* replacement) {
diff --git a/src/factories/Vec3fFactory.cpp b/src/factories/Vec3fFactory.cpp
index 41b7bfb..ab8f7f3 100644
--- a/src/factories/Vec3fFactory.cpp
+++ b/src/factories/Vec3fFactory.cpp
@@ -37,20 +37,11 @@ ExportResult Vec3fCodeExporter::Export(std::ostream &write, std::shared_ptr<IPar
     const auto symbol = GetSafeNode(node, "symbol", entryName);
     const auto offset = GetSafeNode<uint32_t>(node, "offset");
     auto vecData = std::static_pointer_cast<Vec3fData>(raw);
-    auto off = offset;
-    int i;
-
-    if(IS_SEGMENTED(off)) {
-        off = SEGMENT_OFFSET(off);
-    }
-    if (Companion::Instance->IsDebug()) {
-        write << "// 0x" << std::uppercase << std::hex << off << "\n";
-    }
+    int i = 0;
 
     write << "Vec3f " << symbol << "[] = {";
 
     int cols = 120 / (3 * vecData->mMaxWidth + 8);
-    i = 0;
     for(Vec3f v : vecData->mVecs) {
         if((i++ % cols) == 0) {
             write << "\n" << fourSpaceTab;
@@ -64,7 +55,7 @@ ExportResult Vec3fCodeExporter::Export(std::ostream &write, std::shared_ptr<IPar
         write << "// Count: " << vecData->mVecs.size() << " Vec3fs\n";
     }
 
-    return (IS_SEGMENTED(off) ? SEGMENT_OFFSET(off) : off) + vecData->mVecs.size() * sizeof(Vec3f);
+    return offset + vecData->mVecs.size() * sizeof(Vec3f);
 }
 
 ExportResult Vec3fBinaryExporter::Export(std::ostream &write, std::shared_ptr<IParsedData> raw, std::string& entryName, YAML::Node &node, std::string* replacement ) {
diff --git a/src/factories/VtxFactory.cpp b/src/factories/VtxFactory.cpp
index ee26fe7..928f1c7 100644
--- a/src/factories/VtxFactory.cpp
+++ b/src/factories/VtxFactory.cpp
@@ -24,17 +24,6 @@ ExportResult VtxCodeExporter::Export(std::ostream &write, std::shared_ptr<IParse
     const auto symbol = GetSafeNode(node, "symbol", entryName);
     auto offset = GetSafeNode<uint32_t>(node, "offset");
 
-    if (IS_SEGMENTED(offset)) {
-        offset = SEGMENT_OFFSET(offset);
-    }
-
-    if (Companion::Instance->IsDebug()) {
-        if (IS_SEGMENTED(offset)) {
-            offset = SEGMENT_OFFSET(offset);
-        }
-        write << "// 0x" << std::hex << std::uppercase << offset << "\n";
-    }
-
     write << "Vtx " << symbol << "[] = {\n";
 
     for (int i = 0; i < vtx.size(); ++i) {
@@ -68,7 +57,7 @@ ExportResult VtxCodeExporter::Export(std::ostream &write, std::shared_ptr<IParse
         write << "// count: " << std::to_string(vtx.size()) << " Vtxs\n";
     }
 
-    return (IS_SEGMENTED(offset) ? SEGMENT_OFFSET(offset) : offset) + vtx.size() * sizeof(VtxRaw);
+    return offset + vtx.size() * sizeof(VtxRaw);
 }
 
 ExportResult VtxBinaryExporter::Export(std::ostream &write, std::shared_ptr<IParsedData> raw, std::string& entryName, YAML::Node &node, std::string* replacement ) {
diff --git a/src/factories/mk64/CourseVtx.cpp b/src/factories/mk64/CourseVtx.cpp
index 524ae6b..d1d9b3a 100644
--- a/src/factories/mk64/CourseVtx.cpp
+++ b/src/factories/mk64/CourseVtx.cpp
@@ -23,10 +23,6 @@ ExportResult MK64::CourseVtxCodeExporter::Export(std::ostream &write, std::share
     const auto symbol = GetSafeNode(node, "symbol", entryName);
     const auto offset = GetSafeNode<uint32_t>(node, "offset");
 
-    if (Companion::Instance->IsDebug()) {
-        write << "// 0x" << std::hex << std::uppercase << offset << "\n";
-    }
-
     write << "CourseVtx " << symbol << "[] = {\n";
 
     for (int i = 0; i < vtx.size(); ++i) {
@@ -51,13 +47,9 @@ ExportResult MK64::CourseVtxCodeExporter::Export(std::ostream &write, std::share
         // {{{ x, y, z }, { tc1, tc2 }, { c1, c2, c3, c4 }}}
         write << "{{{" << NUM(x) << ", " << NUM(y) << ", " << NUM(z) << "}, {" << NUM(tc1) << ", " << NUM(tc2) << "}, {" << COL(c1) << ", " << COL(c2) << ", " << COL(c3) << ", " << COL(c4) << "}}},\n";
     }
+    write << "};\n";
 
-    if (Companion::Instance->IsDebug()) {
-        write << fourSpaceTab << "// 0x" << std::hex << std::uppercase << (offset + (sizeof(CourseVtx) * vtx.size())) << "\n";
-    }
-
-    write << "};\n\n";
-    return std::nullopt;
+    return offset + vtx.size() * sizeof(CourseVtx);
 }
 
 ExportResult MK64::CourseVtxBinaryExporter::Export(std::ostream &write, std::shared_ptr<IParsedData> raw, std::string& entryName, YAML::Node &node, std::string* replacement ) {
diff --git a/src/factories/mk64/SpawnData.cpp b/src/factories/mk64/SpawnData.cpp
index 5397537..44f710a 100644
--- a/src/factories/mk64/SpawnData.cpp
+++ b/src/factories/mk64/SpawnData.cpp
@@ -23,10 +23,6 @@ ExportResult MK64::SpawnDataCodeExporter::Export(std::ostream &write, std::share
     const auto symbol = GetSafeNode(node, "symbol", entryName);
     const auto offset = GetSafeNode<uint32_t>(node, "offset");
 
-    if (Companion::Instance->IsDebug()) {
-        write << "// 0x" << std::hex << std::uppercase << offset << "\n";
-    }
-
     write << "ActorSpawnData " << symbol << "[] = {\n";
 
     for (int i = 0; i < spawns.size(); i++) {
@@ -45,7 +41,7 @@ ExportResult MK64::SpawnDataCodeExporter::Export(std::ostream &write, std::share
     }
     write << "};\n";
 
-    return (IS_SEGMENTED(offset) ? SEGMENT_OFFSET(offset) : offset) + (sizeof(MK64::ActorSpawnData) * spawns.size());
+    return offset + spawns.size() * sizeof(MK64::ActorSpawnData);
 }
 
 ExportResult MK64::SpawnDataBinaryExporter::Export(std::ostream &write, std::shared_ptr<IParsedData> raw, std::string& entryName, YAML::Node &node, std::string* replacement ) {
diff --git a/src/factories/mk64/TrackSections.cpp b/src/factories/mk64/TrackSections.cpp
index 1c1319e..8e8690f 100644
--- a/src/factories/mk64/TrackSections.cpp
+++ b/src/factories/mk64/TrackSections.cpp
@@ -46,7 +46,7 @@ ExportResult MK64::TrackSectionsCodeExporter::Export(std::ostream &write, std::s
     }
     write << "};\n";
 
-    return (IS_SEGMENTED(offset) ? SEGMENT_OFFSET(offset) : offset) + (sizeof(MK64::TrackSections) * sections.size());
+    return offset + sections.size() * sizeof(MK64::TrackSections);
 }
 
 ExportResult MK64::TrackSectionsBinaryExporter::Export(std::ostream &write, std::shared_ptr<IParsedData> raw, std::string& entryName, YAML::Node &node, std::string* replacement ) {
diff --git a/src/factories/mk64/Waypoints.cpp b/src/factories/mk64/Waypoints.cpp
index 81e6b36..ec203f2 100644
--- a/src/factories/mk64/Waypoints.cpp
+++ b/src/factories/mk64/Waypoints.cpp
@@ -21,6 +21,7 @@ ExportResult MK64::WaypointHeaderExporter::Export(std::ostream &write, std::shar
 ExportResult MK64::WaypointCodeExporter::Export(std::ostream &write, std::shared_ptr<IParsedData> raw, std::string& entryName, YAML::Node &node, std::string* replacement ) {
     auto waypoints = std::static_pointer_cast<WaypointData>(raw)->mWaypoints;
     auto symbol = GetSafeNode(node, "symbol", entryName);
+    auto offset = GetSafeNode<uint32_t>(node, "offset");
 
     write << "TrackWaypoint " << symbol << "[] = {\n";
 
@@ -39,8 +40,9 @@ ExportResult MK64::WaypointCodeExporter::Export(std::ostream &write, std::shared
         // {{{ x, y, z }, f, { tc1, tc2 }, { c1, c2, c3, c4 }}}
         write << "{" << NUM(x) << ", " << NUM(y) << ", " << NUM(z) << ", " << NUM(seg) << " },\n";
     }
-    write << "};\n\n";
-    return std::nullopt;
+    write << "};\n";
+
+    return offset + waypoints.size() * sizeof(MK64::TrackWaypoint);
 }
 
 ExportResult MK64::WaypointBinaryExporter::Export(std::ostream &write, std::shared_ptr<IParsedData> raw, std::string& entryName, YAML::Node &node, std::string* replacement ) {
diff --git a/src/factories/sf64/AnimFactory.cpp b/src/factories/sf64/AnimFactory.cpp
index 7e5eeb2..5eb1e3c 100644
--- a/src/factories/sf64/AnimFactory.cpp
+++ b/src/factories/sf64/AnimFactory.cpp
@@ -63,9 +63,6 @@ ExportResult SF64::AnimCodeExporter::Export(std::ostream &write, std::shared_ptr
     keyDefaultName << symbol << "_joint_key_" << std::uppercase << std::hex << keyOffset;
     auto keyName = GetSafeNode(node, "data_symbol", keyDefaultName.str());
 
-    if (Companion::Instance->IsDebug()) {
-        write << "// 0x" << std::uppercase << std::hex << dataOffset << "\n";
-    }
     auto dataCount = anim->mFrameData.size();
     // write << "Frame data end: 0x" << std::hex << std::uppercase << (dataOffset + sizeof(uint16_t) * dataCount) << "\n";
     // write << "JointKey start: 0x" << std::hex << std::uppercase << keyOffset << "\n";
@@ -98,7 +95,7 @@ ExportResult SF64::AnimCodeExporter::Export(std::ostream &write, std::shared_ptr
 
     return OffsetEntry {
         anim->mDataOffset,
-        (IS_SEGMENTED(offset) ? SEGMENT_OFFSET(offset) : offset) + 0xC
+        offset + 0xC
     };
 }
 
diff --git a/src/factories/sf64/ColPolyFactory.cpp b/src/factories/sf64/ColPolyFactory.cpp
index 9f8bb50..1ff3135 100644
--- a/src/factories/sf64/ColPolyFactory.cpp
+++ b/src/factories/sf64/ColPolyFactory.cpp
@@ -29,14 +29,8 @@ ExportResult SF64::ColPolyCodeExporter::Export(std::ostream &write, std::shared_
     const auto symbol = GetSafeNode(node, "symbol", entryName);
     const auto offset = GetSafeNode<uint32_t>(node, "offset");
     auto colpolys = std::static_pointer_cast<SF64::ColPolyData>(raw);
-    auto off = offset;
+    auto off = ASSET_PTR(offset);
     int i;
-    if(IS_SEGMENTED(off)) {
-        off = SEGMENT_OFFSET(off);
-    }
-    if (Companion::Instance->IsDebug()) {
-        write << "// 0x" << std::uppercase << std::hex << off << "\n";
-    }
 
     write << "CollisionPoly " << symbol << "[] = {";
     int width = std::log10(colpolys->mMesh.size()) + 1;
@@ -75,10 +69,7 @@ ExportResult SF64::ColPolyCodeExporter::Export(std::ostream &write, std::shared_
     if (meshOffset != defaultMeshOffset) {
         write << "// SF64:COLPOLY alert: Gap detected between polys and mesh\n\n";
     }
-    off = meshOffset;
-    if(IS_SEGMENTED(off)) {
-        off = SEGMENT_OFFSET(off);
-    }
+    off = ASSET_PTR(meshOffset);
     defaultMeshSymbol << symbol << "_mesh_" << std::uppercase << std::hex << off;
     auto meshSymbol = GetSafeNode(node, "mesh_symbol", defaultMeshSymbol.str());
 
@@ -108,7 +99,7 @@ ExportResult SF64::ColPolyCodeExporter::Export(std::ostream &write, std::shared_
         write << "// Mesh vertex count: " << colpolys->mMesh.size() << "\n";
     }
 
-    return (IS_SEGMENTED(offset) ? SEGMENT_OFFSET(offset) : offset) + colpolys->mMesh.size() * sizeof(Vec3s);
+    return offset + colpolys->mMesh.size() * sizeof(Vec3s);
 }
 
 ExportResult SF64::ColPolyBinaryExporter::Export(std::ostream &write, std::shared_ptr<IParsedData> raw, std::string& entryName, YAML::Node &node, std::string* replacement ) {
diff --git a/src/factories/sf64/EnvSettingsFactory.cpp b/src/factories/sf64/EnvSettingsFactory.cpp
index aeda5cb..a75912b 100644
--- a/src/factories/sf64/EnvSettingsFactory.cpp
+++ b/src/factories/sf64/EnvSettingsFactory.cpp
@@ -25,13 +25,7 @@ ExportResult SF64::EnvSettingsCodeExporter::Export(std::ostream &write, std::sha
     const auto symbol = GetSafeNode(node, "symbol", entryName);
     const auto offset = GetSafeNode<uint32_t>(node, "offset");
     auto env = std::static_pointer_cast<SF64::EnvSettingsData>(raw);
-    auto off = offset;
-    if(IS_SEGMENTED(off)) {
-        off = SEGMENT_OFFSET(off);
-    }
-    if (Companion::Instance->IsDebug()) {
-        write << "// 0x" << std::uppercase << std::hex << off << "\n";
-    }
+
     write << "EnvSettings " << symbol << " = {\n";
     write << fourSpaceTab;
     write << std::dec << env->mType << ", ";
@@ -56,7 +50,7 @@ ExportResult SF64::EnvSettingsCodeExporter::Export(std::ostream &write, std::sha
     write << env->mAmbB << ",\n";
     write << "};\n";
 
-    return (IS_SEGMENTED(offset) ? SEGMENT_OFFSET(offset) : offset) + sizeof(EnvSettingsData);
+    return offset + sizeof(EnvSettingsData);
 }
 
 ExportResult SF64::EnvSettingsBinaryExporter::Export(std::ostream &write, std::shared_ptr<IParsedData> raw, std::string& entryName, YAML::Node &node, std::string* replacement ) {
diff --git a/src/factories/sf64/HitboxFactory.cpp b/src/factories/sf64/HitboxFactory.cpp
index be453a0..5762ada 100644
--- a/src/factories/sf64/HitboxFactory.cpp
+++ b/src/factories/sf64/HitboxFactory.cpp
@@ -30,20 +30,14 @@ ExportResult SF64::HitboxCodeExporter::Export(std::ostream &write, std::shared_p
     auto index = 0;
     auto count = hitbox->mData[index++];
     auto hasType2 = false;
-    auto off = offset;
 
-    if(IS_SEGMENTED(off)) {
-        off = SEGMENT_OFFSET(off);
-    }
     for(int type : hitbox->mTypes) {
         if(type == 2) {
             hasType2 = true;
             break;
         }
     }
-    if (Companion::Instance->IsDebug()) {
-        write << "// 0x" << std::uppercase << std::hex << off << "\n";
-    }
+
     write << "f32 " << symbol << "[] = {\n";
     write << fourSpaceTab << count << ",\n";
 
@@ -78,7 +72,7 @@ ExportResult SF64::HitboxCodeExporter::Export(std::ostream &write, std::shared_p
     }
     write << "};\n";
 
-    return (IS_SEGMENTED(offset) ? SEGMENT_OFFSET(offset) : offset) + sizeof(float) * index;
+    return offset + sizeof(float) * index;
 }
 
 ExportResult SF64::HitboxBinaryExporter::Export(std::ostream &write, std::shared_ptr<IParsedData> raw, std::string& entryName, YAML::Node &node, std::string* replacement ) {
diff --git a/src/factories/sf64/MessageFactory.cpp b/src/factories/sf64/MessageFactory.cpp
index 8ac966f..039db8a 100644
--- a/src/factories/sf64/MessageFactory.cpp
+++ b/src/factories/sf64/MessageFactory.cpp
@@ -79,17 +79,6 @@ ExportResult SF64::MessageCodeExporter::Export(std::ostream &write, std::shared_
     const auto symbol = GetSafeNode(node, "symbol", entryName);
     auto offset = GetSafeNode<uint32_t>(node, "offset");
 
-    if (IS_SEGMENTED(offset)) {
-        offset = SEGMENT_OFFSET(offset);
-    }
-
-    if (Companion::Instance->IsDebug()) {
-        if (IS_SEGMENTED(offset)) {
-            offset = SEGMENT_OFFSET(offset);
-        }
-        write << "// 0x" << std::hex << std::uppercase << offset << "\n";
-    }
-
     write << "// ";
     bool lastWasSpace = false;
     for (int i = 0; i < message.size(); ++i) {
@@ -132,7 +121,7 @@ ExportResult SF64::MessageCodeExporter::Export(std::ostream &write, std::shared_
         write << "// count: " << std::to_string(message.size()) << " chars\n";
     }
 
-    return (IS_SEGMENTED(offset) ? SEGMENT_OFFSET(offset) : offset) + message.size() * sizeof(uint16_t);
+    return offset + message.size() * sizeof(uint16_t);
 }
 
 ExportResult SF64::MessageBinaryExporter::Export(std::ostream &write, std::shared_ptr<IParsedData> raw, std::string& entryName, YAML::Node &node, std::string* replacement ) {
diff --git a/src/factories/sf64/MessageLookupFactory.cpp b/src/factories/sf64/MessageLookupFactory.cpp
index 5317a40..6aeae05 100644
--- a/src/factories/sf64/MessageLookupFactory.cpp
+++ b/src/factories/sf64/MessageLookupFactory.cpp
@@ -21,17 +21,6 @@ ExportResult SF64::MessageLookupCodeExporter::Export(std::ostream &write, std::s
     const auto symbol = GetSafeNode(node, "symbol", entryName);
     auto offset = GetSafeNode<uint32_t>(node, "offset");
 
-    if (IS_SEGMENTED(offset)) {
-        offset = SEGMENT_OFFSET(offset);
-    }
-
-    if (Companion::Instance->IsDebug()) {
-        if (IS_SEGMENTED(offset)) {
-            offset = SEGMENT_OFFSET(offset);
-        }
-        write << "// 0x" << std::hex << std::uppercase << offset << "\n";
-    }
-
     write << "// clang-format on\n";
     write << "MsgLookup " << symbol << "[] = {\n" << fourSpaceTab;
     for (int i = 0; i < table.size(); ++i) {
@@ -52,7 +41,7 @@ ExportResult SF64::MessageLookupCodeExporter::Export(std::ostream &write, std::s
     }
 
     write << "\n};\n";
-    return (IS_SEGMENTED(offset) ? SEGMENT_OFFSET(offset) : offset) + table.size() * sizeof(uint16_t);
+    return offset + table.size() * sizeof(uint16_t);
 }
 
 ExportResult SF64::MessageLookupBinaryExporter::Export(std::ostream &write, std::shared_ptr<IParsedData> raw, std::string& entryName, YAML::Node &node, std::string* replacement ) {
diff --git a/src/factories/sf64/ObjInitFactory.cpp b/src/factories/sf64/ObjInitFactory.cpp
index 8a18033..6a65ec5 100644
--- a/src/factories/sf64/ObjInitFactory.cpp
+++ b/src/factories/sf64/ObjInitFactory.cpp
@@ -22,13 +22,6 @@ ExportResult SF64::ObjInitCodeExporter::Export(std::ostream &write, std::shared_
     auto offset = GetSafeNode<uint32_t>(node, "offset");
     auto objs = std::static_pointer_cast<ObjInitData>(raw)->mObjInit;
 
-    if (Companion::Instance->IsDebug()) {
-        if (IS_SEGMENTED(offset)) {
-            offset = SEGMENT_OFFSET(offset);
-        }
-        write << "// 0x" << std::hex << std::uppercase << offset << "\n";
-    }
-
     write << "ObjectInit " << symbol << "[] = {\n";
     for(auto& obj : objs) {
         auto enumName = Companion::Instance->GetEnumFromValue("ObjectId", obj.id).value_or(std::to_string(obj.id));
@@ -46,7 +39,7 @@ ExportResult SF64::ObjInitCodeExporter::Export(std::ostream &write, std::shared_
         write << "// count: " << std::to_string(objs.size()) << " ObjectInits\n";
     }
 
-    return (IS_SEGMENTED(offset) ? SEGMENT_OFFSET(offset) : offset) + sizeof(ObjectInit) * objs.size();
+    return offset + sizeof(ObjectInit) * objs.size();
 }
 
 ExportResult SF64::ObjInitBinaryExporter::Export(std::ostream &write, std::shared_ptr<IParsedData> raw, std::string& entryName, YAML::Node &node, std::string* replacement ) {
diff --git a/src/factories/sf64/ScriptFactory.cpp b/src/factories/sf64/ScriptFactory.cpp
index 03c1c6d..75f05f8 100644
--- a/src/factories/sf64/ScriptFactory.cpp
+++ b/src/factories/sf64/ScriptFactory.cpp
@@ -40,13 +40,9 @@ ExportResult SF64::ScriptCodeExporter::Export(std::ostream &write, std::shared_p
     auto sortedPtrs = script->mPtrs;
     std::sort(sortedPtrs.begin(), sortedPtrs.end());
     std::vector<std::string> scriptNames;
-    auto cmdOff = script->mCmdsStart;
+    auto cmdOff = ASSET_PTR(script->mCmdsStart);
     auto cmdIndex = 0;
 
-    if(IS_SEGMENTED(cmdOff)) {
-        cmdOff = SEGMENT_OFFSET(cmdOff);
-    }
-
     for(int i = 0; i < sortedPtrs.size(); i++) {
         std::ostringstream scriptDefaultName;
         scriptDefaultName << symbol << "_cmds_" << std::uppercase << std::hex << cmdOff;
@@ -75,13 +71,7 @@ ExportResult SF64::ScriptCodeExporter::Export(std::ostream &write, std::shared_p
         write << "\n";
     }
 
-    if (Companion::Instance->IsDebug()) {
-        if (IS_SEGMENTED(offset)) {
-            offset = SEGMENT_OFFSET(offset);
-        }
-        write << "// 0x" << std::hex << std::uppercase << offset << "\n";
-    }
-
+    write << "// 0x" << std::hex << std::uppercase << ASSET_PTR(offset) << "\n";
     write << "u16* " << symbol << "[] = {";
     for(int i = 0; i < script->mPtrs.size(); i++) {
         if((i % 5) == 0) {
@@ -97,7 +87,7 @@ ExportResult SF64::ScriptCodeExporter::Export(std::ostream &write, std::shared_p
 
     return OffsetEntry {
         script->mCmdsStart,
-        static_cast<uint32_t>((IS_SEGMENTED(offset) ? SEGMENT_OFFSET(offset) : offset) + script->mPtrs.size() * sizeof(uint32_t))
+        static_cast<uint32_t>(offset + script->mPtrs.size() * sizeof(uint32_t))
     };
 }
 
diff --git a/src/factories/sf64/SkeletonFactory.cpp b/src/factories/sf64/SkeletonFactory.cpp
index 8394ef3..0efce32 100644
--- a/src/factories/sf64/SkeletonFactory.cpp
+++ b/src/factories/sf64/SkeletonFactory.cpp
@@ -33,20 +33,10 @@ ExportResult SF64::SkeletonCodeExporter::Export(std::ostream &write, std::shared
     std::sort(limbs.begin(), limbs.end(), [](SF64::LimbData a, SF64::LimbData b) {return a.mAddr < b.mAddr;});
     std::map<uint32_t, std::string> limbDict;
 
-    if (Companion::Instance->IsDebug()) {
-        int off = limbs[0].mAddr;
-        if (IS_SEGMENTED(off)) {
-            off = SEGMENT_OFFSET(off);
-        }
-        write << "// 0x" << std::hex << std::uppercase << off << "\n";
-    }
     limbDict[0] = "NULL";
     for(SF64::LimbData limb : limbs) {
         std::ostringstream limbDefaultName;
-        auto limbOffset = limb.mAddr;
-        if(IS_SEGMENTED(limbOffset)){
-            limbOffset = SEGMENT_OFFSET(limbOffset);
-        }
+        auto limbOffset = ASSET_PTR(limb.mAddr);
         limbDefaultName << symbol << "_limb_" << std::dec << limb.mIndex << "_" << std::uppercase << std::hex << limbOffset;
         limbDict[limb.mAddr] = limbDefaultName.str();
     }
@@ -92,7 +82,7 @@ ExportResult SF64::SkeletonCodeExporter::Export(std::ostream &write, std::shared
 
     return OffsetEntry {
         limbs[0].mAddr,
-        static_cast<uint32_t>((IS_SEGMENTED(limbs[0].mAddr) ? SEGMENT_OFFSET(limbs[0].mAddr) : limbs[0].mAddr) + skeleton->mSkeleton.size() * 0x24 + 4)
+        static_cast<uint32_t>(limbs[0].mAddr + skeleton->mSkeleton.size() * 0x24 + 4)
     };
 }
 
diff --git a/src/factories/sf64/TriangleFactory.cpp b/src/factories/sf64/TriangleFactory.cpp
index ad3a1ae..52d3bc9 100644
--- a/src/factories/sf64/TriangleFactory.cpp
+++ b/src/factories/sf64/TriangleFactory.cpp
@@ -9,7 +9,6 @@
 
 #define NUM(x, w) std::dec << std::setfill(' ') << std::setw(w) << x
 #define FORMAT_FLOAT(x, w, p) std::dec << std::setfill(' ') << std::fixed << std::setprecision(p) << std::setw(w) << x
-#define STRIP_SEGMENT(offset) (IS_SEGMENTED(offset) ? SEGMENT_OFFSET(offset) : (offset))
 
 SF64::TriangleData::TriangleData(std::vector<Vec3s> tris, std::vector<YAML::Node> meshNodes): mTris(tris), mMeshNodes(meshNodes) {
 }
@@ -31,19 +30,11 @@ ExportResult SF64::TriangleCodeExporter::Export(std::ostream &write, std::shared
     const auto offset = GetSafeNode<uint32_t>(node, "offset");
     auto triData = std::static_pointer_cast<SF64::TriangleData>(raw);
     const auto meshSize = GetSafeNode(triData->mMeshNodes[0], "count", 0);
-    auto off = offset;
     auto segment = 0;
-    int i;
-    if(IS_SEGMENTED(off)) {
-        off = SEGMENT_OFFSET(off);
-    }
-    if (Companion::Instance->IsDebug()) {
-        write << "// 0x" << std::uppercase << std::hex << STRIP_SEGMENT(offset) << "\n";
-    }
+    int width = std::log10(meshSize) + 1;
+    int i = 0;
 
     write << "Triangle " << symbol << "[] = {";
-    int width = std::log10(meshSize) + 1;
-    i = 0;
     for(Vec3s tri : triData->mTris) {
         if((i++ % 6) == 0) {
             write << "\n" << fourSpaceTab;
@@ -57,7 +48,7 @@ ExportResult SF64::TriangleCodeExporter::Export(std::ostream &write, std::shared
         write << "// Triangle count: " << triData->mTris.size() << "\n";
     }
 
-    return (IS_SEGMENTED(offset) ? SEGMENT_OFFSET(offset) : offset) + triData->mTris.size() * sizeof(Vec3s);
+    return offset + triData->mTris.size() * sizeof(Vec3s);
 }
 
 ExportResult SF64::TriangleBinaryExporter::Export(std::ostream &write, std::shared_ptr<IParsedData> raw, std::string& entryName, YAML::Node &node, std::string* replacement ) {
diff --git a/src/utils/Decompressor.cpp b/src/utils/Decompressor.cpp
index 3a2525e..c59d867 100644
--- a/src/utils/Decompressor.cpp
+++ b/src/utils/Decompressor.cpp
@@ -49,7 +49,7 @@ DecompressedData Decompressor::AutoDecode(YAML::Node& node, std::vector<uint8_t>
         case CompressionType::MIO0:
         {
             auto fileOffset = TranslateAddr(offset, true);
-            offset = IS_SEGMENTED(offset) ? SEGMENT_OFFSET(offset) : offset;
+            offset = ASSET_PTR(offset);
 
             auto decoded = Decode(buffer, fileOffset, CompressionType::MIO0);
             auto size = node["size"] ? node["size"].as<size_t>() : manualSize.value_or(decoded->size - offset);
diff --git a/src/utils/Decompressor.h b/src/utils/Decompressor.h
index 4e84cde..0cb5a01 100644
--- a/src/utils/Decompressor.h
+++ b/src/utils/Decompressor.h
@@ -8,10 +8,10 @@
 #include <cstdint>
 
 enum class CompressionType {
+    None,
     MIO0,
     YAY0,
     YAZ0,
-    None,
 };