feat: Rust/#define generators, code tab format/scope combos, enum #define support

- Add Rust #[repr(C)] and #define offset code generators with dispatch
- Add format combo + scope combo + gear button as corner widget on Code tab
- Corner controls hidden on Reclass tab, shown only on Code tab
- Chevron-down SVG arrows on combo dropdowns for consistent styling
- Fix enum #define output: emit named members instead of empty 0x0 struct

src/generator.cpp

@@ -134,6 +134,16 @@ static QString emitField(GenContext& ctx, const Node& node, int depth, int baseO
         return ind + QStringLiteral("%1 %2[%3];").arg(ctx.cType(NodeKind::UTF16), name).arg(node.strLen) + oc;
     case NodeKind::Pointer32:
     case NodeKind::Pointer64: {
+        // Relative pointer (RVA): emit as integer with comment, not a C pointer
+        if (node.isRelative) {
+            QString rvaComment = QStringLiteral(" // rva");
+            if (node.refId != 0) {
+                int refIdx = tree.indexOfId(node.refId);
+                if (refIdx >= 0)
+                    rvaComment += QStringLiteral(" -> ") + ctx.structName(tree.nodes[refIdx]);
+            }
+            return ind + QStringLiteral("%1 %2;").arg(ctx.cType(node.kind), name) + rvaComment + oc;
+        }
         if (node.refId != 0) {
             int refIdx = tree.indexOfId(node.refId);
             if (refIdx >= 0) {
@@ -434,10 +444,440 @@ static QString alignComments(const QString& raw) {
     return result;
 }
 
+// ═══════════════════════════════════════════════════════════════════
+// ── Rust backend ──
+// ═══════════════════════════════════════════════════════════════════
+
+static QString rustTypeName(NodeKind kind) {
+    switch (kind) {
+    case NodeKind::Hex8:      return QStringLiteral("u8");
+    case NodeKind::Hex16:     return QStringLiteral("u16");
+    case NodeKind::Hex32:     return QStringLiteral("u32");
+    case NodeKind::Hex64:     return QStringLiteral("u64");
+    case NodeKind::Int8:      return QStringLiteral("i8");
+    case NodeKind::Int16:     return QStringLiteral("i16");
+    case NodeKind::Int32:     return QStringLiteral("i32");
+    case NodeKind::Int64:     return QStringLiteral("i64");
+    case NodeKind::UInt8:     return QStringLiteral("u8");
+    case NodeKind::UInt16:    return QStringLiteral("u16");
+    case NodeKind::UInt32:    return QStringLiteral("u32");
+    case NodeKind::UInt64:    return QStringLiteral("u64");
+    case NodeKind::Float:     return QStringLiteral("f32");
+    case NodeKind::Double:    return QStringLiteral("f64");
+    case NodeKind::Bool:      return QStringLiteral("bool");
+    case NodeKind::Pointer32: return QStringLiteral("u32");
+    case NodeKind::Pointer64: return QStringLiteral("u64");
+    case NodeKind::FuncPtr32: return QStringLiteral("u32");
+    case NodeKind::FuncPtr64: return QStringLiteral("u64");
+    case NodeKind::Vec2:      return QStringLiteral("f32");
+    case NodeKind::Vec3:      return QStringLiteral("f32");
+    case NodeKind::Vec4:      return QStringLiteral("f32");
+    case NodeKind::Mat4x4:    return QStringLiteral("f32");
+    case NodeKind::UTF8:      return QStringLiteral("u8");
+    case NodeKind::UTF16:     return QStringLiteral("u16");
+    default:                  return QStringLiteral("u8");
+    }
+}
+
+// Forward declaration
+static void emitRustStruct(GenContext& ctx, uint64_t structId);
+
+static QString rustType(GenContext& ctx, NodeKind kind) {
+    if (ctx.typeAliases) {
+        auto it = ctx.typeAliases->find(kind);
+        if (it != ctx.typeAliases->end() && !it.value().isEmpty())
+            return it.value();
+    }
+    return rustTypeName(kind);
+}
+
+static QString emitRustField(GenContext& ctx, const Node& node, int depth, int baseOffset) {
+    const NodeTree& tree = ctx.tree;
+    QString ind = indent(depth);
+    QString name = sanitizeIdent(node.name.isEmpty()
+        ? QStringLiteral("field_%1").arg(node.offset, 2, 16, QChar('0'))
+        : node.name);
+    QString oc = offsetComment(baseOffset + node.offset);
+
+    switch (node.kind) {
+    case NodeKind::Vec2:
+        return ind + QStringLiteral("pub %1: [f32; 2],").arg(name) + oc;
+    case NodeKind::Vec3:
+        return ind + QStringLiteral("pub %1: [f32; 3],").arg(name) + oc;
+    case NodeKind::Vec4:
+        return ind + QStringLiteral("pub %1: [f32; 4],").arg(name) + oc;
+    case NodeKind::Mat4x4:
+        return ind + QStringLiteral("pub %1: [[f32; 4]; 4],").arg(name) + oc;
+    case NodeKind::UTF8:
+        return ind + QStringLiteral("pub %1: [u8; %2],").arg(name).arg(node.strLen) + oc;
+    case NodeKind::UTF16:
+        return ind + QStringLiteral("pub %1: [u16; %2],").arg(name).arg(node.strLen) + oc;
+    case NodeKind::Pointer32:
+    case NodeKind::Pointer64: {
+        if (node.isRelative) {
+            QString comment = QStringLiteral(" // rva");
+            if (node.refId != 0) {
+                int refIdx = tree.indexOfId(node.refId);
+                if (refIdx >= 0)
+                    comment += QStringLiteral(" -> ") + ctx.structName(tree.nodes[refIdx]);
+            }
+            return ind + QStringLiteral("pub %1: %2,").arg(name, rustType(ctx, node.kind)) + comment + oc;
+        }
+        if (node.refId != 0) {
+            int refIdx = tree.indexOfId(node.refId);
+            if (refIdx >= 0) {
+                QString target = ctx.structName(tree.nodes[refIdx]);
+                return ind + QStringLiteral("pub %1: *mut %2,").arg(name, target) + oc;
+            }
+        }
+        bool isNativePtr = (node.kind == NodeKind::Pointer32 && ctx.tree.pointerSize <= 4)
+                        || (node.kind == NodeKind::Pointer64 && ctx.tree.pointerSize >= 8);
+        if (isNativePtr)
+            return ind + QStringLiteral("pub %1: *mut core::ffi::c_void,").arg(name) + oc;
+        return ind + QStringLiteral("pub %1: %2,").arg(name, rustType(ctx, node.kind)) + oc;
+    }
+    case NodeKind::FuncPtr32:
+    case NodeKind::FuncPtr64:
+        return ind + QStringLiteral("pub %1: Option<unsafe extern \"C\" fn()>,").arg(name) + oc;
+    default:
+        return ind + QStringLiteral("pub %1: %2,").arg(name, rustType(ctx, node.kind)) + oc;
+    }
+}
+
+static void emitRustStructBody(GenContext& ctx, uint64_t structId,
+                                bool isUnion, int depth, int baseOffset) {
+    const NodeTree& tree = ctx.tree;
+    int idx = tree.indexOfId(structId);
+    if (idx < 0) return;
+
+    int structSize = tree.structSpan(structId, &ctx.childMap);
+    QString ind = indent(depth);
+
+    QVector<int> allChildren = ctx.childMap.value(structId);
+    QVector<int> children, staticIdxs;
+    for (int ci : allChildren) {
+        if (tree.nodes[ci].isStatic)
+            staticIdxs.append(ci);
+        else
+            children.append(ci);
+    }
+    std::sort(children.begin(), children.end(), [&](int a, int b) {
+        return tree.nodes[a].offset < tree.nodes[b].offset;
+    });
+
+    auto emitPadRun = [&](int relOffset, int size) {
+        if (size <= 0) return;
+        ctx.output += ind + QStringLiteral("pub %1: [u8; 0x%2],")
+            .arg(ctx.uniquePadName())
+            .arg(QString::number(size, 16).toUpper())
+            + offsetComment(baseOffset + relOffset) + QStringLiteral("\n");
+    };
+
+    int cursor = 0;
+    int i = 0;
+
+    while (i < children.size()) {
+        const Node& child = tree.nodes[children[i]];
+        int childSize;
+        if (child.kind == NodeKind::Struct || child.kind == NodeKind::Array)
+            childSize = tree.structSpan(child.id, &ctx.childMap);
+        else
+            childSize = child.byteSize();
+
+        if (!isUnion) {
+            if (child.offset > cursor)
+                emitPadRun(cursor, child.offset - cursor);
+        }
+
+        if (isHexNode(child.kind)) {
+            int runStart = child.offset;
+            int runEnd = child.offset + childSize;
+            int j = i + 1;
+            while (j < children.size()) {
+                const Node& next = tree.nodes[children[j]];
+                if (!isHexNode(next.kind)) break;
+                int nextSize = next.byteSize();
+                if (next.offset < runEnd) break;
+                runEnd = next.offset + nextSize;
+                j++;
+            }
+            emitPadRun(runStart, runEnd - runStart);
+            cursor = runEnd;
+            i = j;
+            continue;
+        }
+
+        if (child.kind == NodeKind::Struct) {
+            if (child.classKeyword == QStringLiteral("bitfield")
+                && !child.bitfieldMembers.isEmpty()) {
+                // Rust has no native bitfields — emit container + comment
+                QString bfType = rustType(ctx, child.elementKind);
+                if (bfType.isEmpty()) bfType = QStringLiteral("u32");
+                QString fieldName = sanitizeIdent(child.name.isEmpty()
+                    ? QStringLiteral("bitfield_%1").arg(child.offset, 2, 16, QChar('0'))
+                    : child.name);
+                QStringList bits;
+                for (const auto& m : child.bitfieldMembers)
+                    bits << QStringLiteral("%1:%2").arg(sanitizeIdent(m.name)).arg(m.bitWidth);
+                ctx.output += ind + QStringLiteral("pub %1: %2,")
+                    .arg(fieldName, bfType)
+                    + QStringLiteral(" // bits: ") + bits.join(QStringLiteral(", "))
+                    + offsetComment(baseOffset + child.offset) + QStringLiteral("\n");
+            } else {
+                bool isAnonymous = child.structTypeName.isEmpty();
+                if (isAnonymous) {
+                    // Rust can't do anonymous inline structs — flatten as byte array
+                    int span = tree.structSpan(child.id, &ctx.childMap);
+                    QString fieldName = sanitizeIdent(child.name.isEmpty()
+                        ? QStringLiteral("anon_%1").arg(child.offset, 2, 16, QChar('0'))
+                        : child.name);
+                    ctx.output += ind + QStringLiteral("pub %1: [u8; 0x%2],")
+                        .arg(fieldName)
+                        .arg(QString::number(span, 16).toUpper())
+                        + offsetComment(baseOffset + child.offset) + QStringLiteral("\n");
+                } else {
+                    QString kw = child.resolvedClassKeyword();
+                    if (kw == QStringLiteral("enum") && child.enumMembers.isEmpty())
+                        kw = QStringLiteral("struct");
+                    QString typeName = sanitizeIdent(child.structTypeName);
+                    QString fieldName = sanitizeIdent(child.name);
+                    ctx.output += ind + QStringLiteral("pub %1: %2,")
+                        .arg(fieldName, typeName)
+                        + offsetComment(baseOffset + child.offset) + QStringLiteral("\n");
+                }
+            }
+        } else if (child.kind == NodeKind::Array) {
+            QVector<int> arrayKids = ctx.childMap.value(child.id);
+            bool hasStructChild = false;
+            QString elemTypeName;
+            for (int ak : arrayKids) {
+                if (tree.nodes[ak].kind == NodeKind::Struct) {
+                    hasStructChild = true;
+                    elemTypeName = ctx.structName(tree.nodes[ak]);
+                    break;
+                }
+            }
+            QString fieldName = sanitizeIdent(child.name);
+            if (hasStructChild && !elemTypeName.isEmpty()) {
+                ctx.output += ind + QStringLiteral("pub %1: [%2; %3],")
+                    .arg(fieldName, elemTypeName).arg(child.arrayLen)
+                    + offsetComment(baseOffset + child.offset) + QStringLiteral("\n");
+            } else {
+                ctx.output += ind + QStringLiteral("pub %1: [%2; %3],")
+                    .arg(fieldName, rustType(ctx, child.elementKind)).arg(child.arrayLen)
+                    + offsetComment(baseOffset + child.offset) + QStringLiteral("\n");
+            }
+        } else {
+            ctx.output += emitRustField(ctx, child, depth, baseOffset) + QStringLiteral("\n");
+        }
+
+        int childEnd = child.offset + childSize;
+        if (childEnd > cursor) cursor = childEnd;
+        i++;
+    }
+
+    if (!isUnion && cursor < structSize)
+        emitPadRun(cursor, structSize - cursor);
+
+    for (int si : staticIdxs) {
+        const Node& sf = tree.nodes[si];
+        QString sfType = sf.structTypeName.isEmpty() ? rustType(ctx, sf.kind) : sf.structTypeName;
+        ctx.output += ind + QStringLiteral("// static: %1 %2 @ %3\n")
+            .arg(sfType, sanitizeIdent(sf.name), sf.offsetExpr);
+    }
+}
+
+static void emitRustStruct(GenContext& ctx, uint64_t structId) {
+    if (ctx.emittedIds.contains(structId)) return;
+    if (ctx.visiting.contains(structId)) return;
+    ctx.visiting.insert(structId);
+
+    int idx = ctx.tree.indexOfId(structId);
+    if (idx < 0) { ctx.visiting.remove(structId); return; }
+
+    const Node& node = ctx.tree.nodes[idx];
+    if (node.kind != NodeKind::Struct) { ctx.visiting.remove(structId); return; }
+
+    QString typeName = ctx.structName(node);
+    if (ctx.emittedTypeNames.contains(typeName)) {
+        ctx.emittedIds.insert(structId);
+        ctx.visiting.remove(structId);
+        return;
+    }
+
+    ctx.emittedIds.insert(structId);
+    ctx.emittedTypeNames.insert(typeName);
+    int structSize = ctx.tree.structSpan(structId, &ctx.childMap);
+
+    QString kw = node.resolvedClassKeyword();
+
+    // Enum with members
+    if (kw == QStringLiteral("enum") && !node.enumMembers.isEmpty()) {
+        ctx.output += QStringLiteral("#[repr(i64)]\npub enum %1 {\n").arg(typeName);
+        for (const auto& m : node.enumMembers) {
+            ctx.output += QStringLiteral("    %1 = %2,\n")
+                .arg(sanitizeIdent(m.first))
+                .arg(m.second);
+        }
+        ctx.output += QStringLiteral("}\n\n");
+        ctx.visiting.remove(structId);
+        return;
+    }
+
+    bool isUnion = (kw == QStringLiteral("union"));
+
+    if (isUnion)
+        ctx.output += QStringLiteral("#[repr(C)]\n#[derive(Copy, Clone)]\npub union %1 {\n").arg(typeName);
+    else
+        ctx.output += QStringLiteral("#[repr(C)]\npub struct %1 {\n").arg(typeName);
+
+    emitRustStructBody(ctx, structId, isUnion, 1, 0);
+
+    ctx.output += QStringLiteral("}")
+        + offsetComment(structSize, true)
+        + QStringLiteral("\n");
+    if (ctx.emitAsserts)
+        ctx.output += QStringLiteral("const _: () = assert!(core::mem::size_of::<%1>() == 0x%2);\n")
+            .arg(typeName)
+            .arg(QString::number(structSize, 16).toUpper());
+    ctx.output += QStringLiteral("\n");
+
+    ctx.visiting.remove(structId);
+}
+
+// ═══════════════════════════════════════════════════════════════════
+// ── #define offsets backend ──
+// ═══════════════════════════════════════════════════════════════════
+
+static void emitDefinesForStruct(GenContext& ctx, uint64_t structId,
+                                  const QString& prefix, int baseOffset) {
+    int idx = ctx.tree.indexOfId(structId);
+    if (idx < 0) return;
+
+    const Node& node = ctx.tree.nodes[idx];
+    QString typeName = prefix.isEmpty() ? ctx.structName(node) : prefix;
+    QString kw = node.resolvedClassKeyword();
+
+    // Enum with members: emit #define EnumName_MemberName value
+    if (kw == QStringLiteral("enum") && !node.enumMembers.isEmpty()) {
+        ctx.output += QStringLiteral("// %1 (enum)\n").arg(typeName);
+        for (const auto& m : node.enumMembers) {
+            ctx.output += QStringLiteral("#define %1_%2 %3\n")
+                .arg(typeName, sanitizeIdent(m.first))
+                .arg(m.second);
+        }
+        ctx.output += QStringLiteral("\n");
+        return;
+    }
+
+    int structSize = ctx.tree.structSpan(structId, &ctx.childMap);
+    ctx.output += QStringLiteral("// %1 (0x%2 bytes)\n")
+        .arg(typeName)
+        .arg(QString::number(structSize, 16).toUpper());
+
+    QVector<int> children = ctx.childMap.value(structId);
+    std::sort(children.begin(), children.end(), [&](int a, int b) {
+        return ctx.tree.nodes[a].offset < ctx.tree.nodes[b].offset;
+    });
+
+    for (int ci : children) {
+        const Node& child = ctx.tree.nodes[ci];
+        if (child.isStatic) continue;
+        if (isHexNode(child.kind)) continue;
+
+        QString fieldName = sanitizeIdent(child.name.isEmpty()
+            ? QStringLiteral("field_%1").arg(child.offset, 2, 16, QChar('0'))
+            : child.name);
+        int absOffset = baseOffset + child.offset;
+
+        ctx.output += QStringLiteral("#define %1_%2 0x%3\n")
+            .arg(typeName, fieldName)
+            .arg(QString::number(absOffset, 16).toUpper());
+
+        // Recurse into named sub-structs
+        if (child.kind == NodeKind::Struct && !child.structTypeName.isEmpty()
+            && child.classKeyword != QStringLiteral("bitfield")) {
+            emitDefinesForStruct(ctx, child.id,
+                typeName + QStringLiteral("_") + fieldName, absOffset);
+        }
+    }
+    ctx.output += QStringLiteral("\n");
+}
+
+// ═══════════════════════════════════════════════════════════════════
+// ── Reachable struct collector (for "Current + Children" scope) ──
+// ═══════════════════════════════════════════════════════════════════
+
+// Walk the tree from rootId, collecting all struct IDs reachable via
+// named struct children and pointer references. Returns them in
+// dependency order (leaves first, root last).
+static QVector<uint64_t> collectReachableStructs(
+    const NodeTree& tree, const QHash<uint64_t, QVector<int>>& childMap,
+    uint64_t rootId)
+{
+    QVector<uint64_t> result;
+    QSet<uint64_t> visited;
+
+    std::function<void(uint64_t)> walk = [&](uint64_t id) {
+        if (visited.contains(id)) return;
+        visited.insert(id);
+
+        int idx = tree.indexOfId(id);
+        if (idx < 0) return;
+        const Node& node = tree.nodes[idx];
+        if (node.kind != NodeKind::Struct) return;
+
+        // Walk children first so dependencies come before the parent
+        for (int ci : childMap.value(id)) {
+            const Node& child = tree.nodes[ci];
+            if (child.kind == NodeKind::Struct && !child.structTypeName.isEmpty())
+                walk(child.id);
+            if ((child.kind == NodeKind::Pointer32 || child.kind == NodeKind::Pointer64)
+                && child.refId != 0)
+                walk(child.refId);
+            if (child.kind == NodeKind::Array) {
+                for (int ak : childMap.value(child.id))
+                    if (tree.nodes[ak].kind == NodeKind::Struct)
+                        walk(tree.nodes[ak].id);
+            }
+        }
+        result.append(id);
+    };
+    walk(rootId);
+    return result;
+}
+
 } // anonymous namespace
 
 // ── Public API ──
 
+const char* codeFormatName(CodeFormat fmt) {
+    switch (fmt) {
+    case CodeFormat::CppHeader:     return "C/C++";
+    case CodeFormat::RustStruct:    return "Rust";
+    case CodeFormat::DefineOffsets: return "#define";
+    default:                        return "C/C++";
+    }
+}
+
+const char* codeFormatFileFilter(CodeFormat fmt) {
+    switch (fmt) {
+    case CodeFormat::CppHeader:     return "C++ Header (*.h);;All Files (*)";
+    case CodeFormat::RustStruct:    return "Rust Source (*.rs);;All Files (*)";
+    case CodeFormat::DefineOffsets: return "C Header (*.h);;All Files (*)";
+    default:                        return "All Files (*)";
+    }
+}
+
+const char* codeScopeName(CodeScope scope) {
+    switch (scope) {
+    case CodeScope::Current:       return "Current";
+    case CodeScope::WithChildren:  return "Current + Deps";
+    case CodeScope::FullSdk:       return "Full SDK";
+    default:                       return "Current";
+    }
+}
+
 QString renderCpp(const NodeTree& tree, uint64_t rootStructId,
                   const QHash<NodeKind, QString>* typeAliases,
                   bool emitAsserts) {
@@ -456,6 +896,23 @@ QString renderCpp(const NodeTree& tree, uint64_t rootStructId,
     return alignComments(ctx.output);
 }
 
+QString renderCppTree(const NodeTree& tree, uint64_t rootStructId,
+                      const QHash<NodeKind, QString>* typeAliases,
+                      bool emitAsserts) {
+    int idx = tree.indexOfId(rootStructId);
+    if (idx < 0) return {};
+    if (tree.nodes[idx].kind != NodeKind::Struct) return {};
+
+    auto childMap = buildChildMap(tree);
+    GenContext ctx{tree, childMap, {}, {}, {}, {}, {}, 0, typeAliases, emitAsserts};
+    ctx.output += QStringLiteral("#pragma once\n\n");
+
+    for (uint64_t sid : collectReachableStructs(tree, childMap, rootStructId))
+        emitStruct(ctx, sid);
+
+    return alignComments(ctx.output);
+}
+
 QString renderCppAll(const NodeTree& tree,
                      const QHash<NodeKind, QString>* typeAliases,
                      bool emitAsserts) {
@@ -476,6 +933,127 @@ QString renderCppAll(const NodeTree& tree,
     return alignComments(ctx.output);
 }
 
+// ── Rust public API ──
+
+QString renderRust(const NodeTree& tree, uint64_t rootStructId,
+                   const QHash<NodeKind, QString>* typeAliases,
+                   bool emitAsserts) {
+    int idx = tree.indexOfId(rootStructId);
+    if (idx < 0) return {};
+    if (tree.nodes[idx].kind != NodeKind::Struct) return {};
+
+    GenContext ctx{tree, buildChildMap(tree), {}, {}, {}, {}, {}, 0, typeAliases, emitAsserts};
+    ctx.output += QStringLiteral("// Generated by Reclass 2027\n\n");
+    emitRustStruct(ctx, rootStructId);
+    return alignComments(ctx.output);
+}
+
+QString renderRustTree(const NodeTree& tree, uint64_t rootStructId,
+                       const QHash<NodeKind, QString>* typeAliases,
+                       bool emitAsserts) {
+    int idx = tree.indexOfId(rootStructId);
+    if (idx < 0) return {};
+    if (tree.nodes[idx].kind != NodeKind::Struct) return {};
+
+    auto childMap = buildChildMap(tree);
+    GenContext ctx{tree, childMap, {}, {}, {}, {}, {}, 0, typeAliases, emitAsserts};
+    ctx.output += QStringLiteral("// Generated by Reclass 2027\n\n");
+
+    for (uint64_t sid : collectReachableStructs(tree, childMap, rootStructId))
+        emitRustStruct(ctx, sid);
+
+    return alignComments(ctx.output);
+}
+
+QString renderRustAll(const NodeTree& tree,
+                      const QHash<NodeKind, QString>* typeAliases,
+                      bool emitAsserts) {
+    GenContext ctx{tree, buildChildMap(tree), {}, {}, {}, {}, {}, 0, typeAliases, emitAsserts};
+    ctx.output += QStringLiteral("// Generated by Reclass 2027\n\n");
+
+    QVector<int> roots = ctx.childMap.value(0);
+    std::sort(roots.begin(), roots.end(), [&](int a, int b) {
+        return tree.nodes[a].offset < tree.nodes[b].offset;
+    });
+    for (int ri : roots) {
+        if (tree.nodes[ri].kind == NodeKind::Struct)
+            emitRustStruct(ctx, tree.nodes[ri].id);
+    }
+    return alignComments(ctx.output);
+}
+
+// ── #define public API ──
+
+QString renderDefines(const NodeTree& tree, uint64_t rootStructId) {
+    int idx = tree.indexOfId(rootStructId);
+    if (idx < 0) return {};
+    if (tree.nodes[idx].kind != NodeKind::Struct) return {};
+
+    GenContext ctx{tree, buildChildMap(tree), {}, {}, {}, {}, {}, 0, nullptr, false};
+    ctx.output += QStringLiteral("#pragma once\n\n");
+    emitDefinesForStruct(ctx, rootStructId, QString(), 0);
+    return ctx.output;
+}
+
+QString renderDefinesTree(const NodeTree& tree, uint64_t rootStructId) {
+    int idx = tree.indexOfId(rootStructId);
+    if (idx < 0) return {};
+    if (tree.nodes[idx].kind != NodeKind::Struct) return {};
+
+    auto childMap = buildChildMap(tree);
+    GenContext ctx{tree, childMap, {}, {}, {}, {}, {}, 0, nullptr, false};
+    ctx.output += QStringLiteral("#pragma once\n\n");
+
+    for (uint64_t sid : collectReachableStructs(tree, childMap, rootStructId))
+        emitDefinesForStruct(ctx, sid, QString(), 0);
+
+    return ctx.output;
+}
+
+QString renderDefinesAll(const NodeTree& tree) {
+    GenContext ctx{tree, buildChildMap(tree), {}, {}, {}, {}, {}, 0, nullptr, false};
+    ctx.output += QStringLiteral("#pragma once\n\n");
+
+    QVector<int> roots = ctx.childMap.value(0);
+    std::sort(roots.begin(), roots.end(), [&](int a, int b) {
+        return tree.nodes[a].offset < tree.nodes[b].offset;
+    });
+    for (int ri : roots) {
+        if (tree.nodes[ri].kind == NodeKind::Struct)
+            emitDefinesForStruct(ctx, tree.nodes[ri].id, QString(), 0);
+    }
+    return ctx.output;
+}
+
+// ── Format dispatch ──
+
+QString renderCode(CodeFormat fmt, const NodeTree& tree, uint64_t rootStructId,
+                   const QHash<NodeKind, QString>* typeAliases, bool emitAsserts) {
+    switch (fmt) {
+    case CodeFormat::RustStruct:    return renderRust(tree, rootStructId, typeAliases, emitAsserts);
+    case CodeFormat::DefineOffsets: return renderDefines(tree, rootStructId);
+    default:                        return renderCpp(tree, rootStructId, typeAliases, emitAsserts);
+    }
+}
+
+QString renderCodeTree(CodeFormat fmt, const NodeTree& tree, uint64_t rootStructId,
+                       const QHash<NodeKind, QString>* typeAliases, bool emitAsserts) {
+    switch (fmt) {
+    case CodeFormat::RustStruct:    return renderRustTree(tree, rootStructId, typeAliases, emitAsserts);
+    case CodeFormat::DefineOffsets: return renderDefinesTree(tree, rootStructId);
+    default:                        return renderCppTree(tree, rootStructId, typeAliases, emitAsserts);
+    }
+}
+
+QString renderCodeAll(CodeFormat fmt, const NodeTree& tree,
+                      const QHash<NodeKind, QString>* typeAliases, bool emitAsserts) {
+    switch (fmt) {
+    case CodeFormat::RustStruct:    return renderRustAll(tree, typeAliases, emitAsserts);
+    case CodeFormat::DefineOffsets: return renderDefinesAll(tree);
+    default:                        return renderCppAll(tree, typeAliases, emitAsserts);
+    }
+}
+
 QString renderNull(const NodeTree&, uint64_t) {
     return {};
 }