Add StructuredDataDef viewer and parsing

Introduce support for IW4/MW2 StructuredDataDef assets: add StructuredDataDefAsset model (name, offset, counts, DumpText), wire parsing in Iw4AssetBridge (convert StructuredDataDefSet -> model and render human-readable dumps), and expose a new "Struct Data" tab in MainWindowForm with a list and double-click viewer. Add a read-only StructuredDataDefViewerForm to display/copy the layout dump. Extend game definitions: add IsStructuredDataDefType to IGameDefinition and GameDefinitionBase, and implement recognition in MW2GameDefinition with platform-specific asset IDs. Register the new viewer form in the project file. The feature is read-only and relies on the IW4 pointer-walk reader to produce layout dumps (available for MW2 PS3 via the walker).

Author: primetime43

Call of Duty FastFile Editor/Call of Duty FastFile Editor.csproj.user

@@ -37,6 +37,9 @@
     <Compile Update="UI\StringTableViewerForm.cs">
       <SubType>Form</SubType>
     </Compile>
+    <Compile Update="UI\StructuredDataDefViewerForm.cs">
+      <SubType>Form</SubType>
+    </Compile>
     <Compile Update="UI\SupportedFormatsForm.cs">
       <SubType>Form</SubType>
     </Compile>

Call of Duty FastFile Editor/GameDefinitions/GameDefinitionBase.cs

@@ -28,6 +28,7 @@ public abstract class GameDefinitionBase : IGameDefinition
             "stringtable",
             "weapon",
             "image",
+            "structureddatadef",
             "col_map_sp",
             "col_map_mp"
         };
@@ -55,6 +56,7 @@ public abstract class GameDefinitionBase : IGameDefinition
         public virtual bool IsXAnimType(int assetType) => assetType == XAnimAssetType;
         public virtual bool IsMaterialType(int assetType) => false; // Override in game-specific definitions
         public virtual bool IsTechSetType(int assetType) => false; // Override in game-specific definitions
+        public virtual bool IsStructuredDataDefType(int assetType) => false; // Override in game-specific definitions
         public virtual bool IsStringTableType(int assetType) => assetType == StringTableAssetType;
         public virtual bool IsWeaponType(int assetType) => WeaponAssetType != 0 && assetType == WeaponAssetType;
         public virtual bool IsImageType(int assetType) => ImageAssetType != 0 && assetType == ImageAssetType;

Call of Duty FastFile Editor/GameDefinitions/IGameDefinition.cs

@@ -153,6 +153,11 @@ public interface IGameDefinition
         /// </summary>
         bool IsStringTableType(int assetType);
 
+        /// <summary>
+        /// Checks if the given asset type value is a structureddatadef.
+        /// </summary>
+        bool IsStructuredDataDefType(int assetType);
+
         /// <summary>
         /// Parses a material asset from the zone data at the given offset.
         /// </summary>

Call of Duty FastFile Editor/GameDefinitions/MW2GameDefinition.cs

@@ -87,6 +87,19 @@ public MW2GameDefinition(bool isXbox360, bool isPC = false)
         /// </summary>
         public override bool IsTechSetType(int assetType) => assetType == TechSetAssetType;
 
+        /// <summary>
+        /// MW2 StructuredDataDef asset type ID. PS3 = 0x26, Xbox 360 = 0x25, PC = 0x27.
+        /// </summary>
+        public byte StructuredDataDefAssetType => IsPC
+            ? (byte)MW2AssetTypePC.structureddatadef
+            : (IsXbox360 ? (byte)MW2AssetTypeXbox360.structureddatadef : (byte)MW2AssetTypePS3.structureddatadef);
+
+        /// <summary>
+        /// Recognise structureddatadef records so the Asset Pool view names them. For MW2 PS3 the
+        /// def layout is dumped from the IW4 pointer-walk; other platforms have no parser yet.
+        /// </summary>
+        public override bool IsStructuredDataDefType(int assetType) => assetType == StructuredDataDefAssetType;
+
         public override string GetAssetTypeName(int assetType)
         {
             if (IsPC)

Call of Duty FastFile Editor/Models/StructuredDataDefAsset.cs

@@ -0,0 +1,35 @@
+namespace Call_of_Duty_FastFile_Editor.Models
+{
+    /// <summary>
+    /// Editor-side view model for a StructuredDataDefSet asset (MW2 / IW4).
+    ///
+    /// The structureddatadef asset stores the data-structure + enum layouts the game uses (defined
+    /// under raw/mp/*.def). The original source format isn't shipped, so this is a read-only
+    /// <b>dump</b> of the parsed layout: each def's enums (entry name = enum value), structs
+    /// (property name : type @ byte offset), indexed/enumed arrays, and the root type. The IW4
+    /// pointer-walk reader (<c>FastFileLib.Iw4.StructuredDataReader</c>) produces the structure;
+    /// <c>Iw4AssetBridge</c> renders <see cref="DumpText"/> from it.
+    /// </summary>
+    public class StructuredDataDefAsset
+    {
+        /// <summary>DefSet name (e.g. <c>mp/playerconstantdata.def</c>).</summary>
+        public string Name { get; set; } = string.Empty;
+
+        /// <summary>Zone byte offset of the DefSet asset header.</summary>
+        public int Offset { get; set; }
+
+        /// <summary>Number of <c>StructuredDataDef</c>s in the set.</summary>
+        public int DefCount { get; set; }
+
+        /// <summary>Total enums across all defs (for the list summary).</summary>
+        public int EnumCount { get; set; }
+
+        /// <summary>Total structs across all defs (for the list summary).</summary>
+        public int StructCount { get; set; }
+
+        /// <summary>Pre-rendered, human-readable dump of the parsed layout (shown in the viewer).</summary>
+        public string DumpText { get; set; } = string.Empty;
+
+        public override string ToString() => Name;
+    }
+}

Call of Duty FastFile Editor/Services/Iw4AssetBridge.cs

@@ -15,6 +15,7 @@ public sealed class Iw4BridgeResult
         public List<WeaponAsset> Weapons { get; } = new();
         public List<TechSetAsset> TechSets { get; } = new();
         public List<MenuList> MenuLists { get; } = new();
+        public List<StructuredDataDefAsset> StructuredDataDefs { get; } = new();
     }
 
     /// <summary>
@@ -97,6 +98,9 @@ public static class Iw4AssetBridge
                     case FastFileLib.Iw4.MenuList ml:
                         iw4MenuLists.Add(ml);
                         break;
+                    case FastFileLib.Iw4.StructuredDataDefSet sd:
+                        result.StructuredDataDefs.Add(ToStructuredDataDef(sd));
+                        break;
                 }
             }
 
@@ -444,5 +448,111 @@ private static TechSetAsset ToTechSet(FastFileLib.Iw4.MaterialTechniqueSet ts)
                 AdditionalData = "IW4 pointer-walk",
             };
         }
+
+        // ---- StructuredDataDef (IW4 raw/mp/*.def layout dump) ----
+
+        private static StructuredDataDefAsset ToStructuredDataDef(FastFileLib.Iw4.StructuredDataDefSet sd)
+        {
+            var defs = sd.DefsPtr is { IsResolved: true, Result: not null }
+                ? sd.DefsPtr.Result
+                : Array.Empty<FastFileLib.Iw4.StructuredDataDef>();
+
+            return new StructuredDataDefAsset
+            {
+                Name = sd.Name,
+                Offset = sd.Offset,
+                DefCount = sd.DefCount,
+                EnumCount = defs.Sum(d => d.EnumCount),
+                StructCount = defs.Sum(d => d.StructCount),
+                DumpText = RenderStructuredDataDump(sd, defs),
+            };
+        }
+
+        /// <summary>Renders a StructuredDataType (the spec's tagged union) to a readable type string.</summary>
+        private static string TypeString(FastFileLib.Iw4.StructuredDataType? t)
+        {
+            if (t == null) return "?";
+            return t.Type switch
+            {
+                FastFileLib.Iw4.StructuredDataTypeCategory.DataInt => "int",
+                FastFileLib.Iw4.StructuredDataTypeCategory.DataByte => "byte",
+                FastFileLib.Iw4.StructuredDataTypeCategory.DataBool => "bool",
+                FastFileLib.Iw4.StructuredDataTypeCategory.DataString => $"string[{t.UnionValue}]",
+                FastFileLib.Iw4.StructuredDataTypeCategory.DataEnum => $"enum[{t.UnionValue}]",
+                FastFileLib.Iw4.StructuredDataTypeCategory.DataStruct => $"struct[{t.UnionValue}]",
+                FastFileLib.Iw4.StructuredDataTypeCategory.DataIndexedArray => $"indexedArray[{t.UnionValue}]",
+                FastFileLib.Iw4.StructuredDataTypeCategory.DataEnumArray => $"enumArray[{t.UnionValue}]",
+                FastFileLib.Iw4.StructuredDataTypeCategory.DataFloat => "float",
+                FastFileLib.Iw4.StructuredDataTypeCategory.DataShort => "short",
+                FastFileLib.Iw4.StructuredDataTypeCategory.DataCount => "count",
+                _ => $"type{(int)t.Type}",
+            };
+        }
+
+        private static T[] Resolve<T>(FastFileLib.Iw4.ZonePointer<T[]>? p)
+            => p is { IsResolved: true, Result: not null } ? p.Result : Array.Empty<T>();
+
+        private static string RenderStructuredDataDump(
+            FastFileLib.Iw4.StructuredDataDefSet sd, FastFileLib.Iw4.StructuredDataDef[] defs)
+        {
+            var sb = new StringBuilder();
+            sb.AppendLine($"// {sd.Name}");
+            sb.AppendLine($"// StructuredDataDefSet  —  defCount = {sd.DefCount}");
+            sb.AppendLine();
+
+            for (int di = 0; di < defs.Length; di++)
+            {
+                var def = defs[di];
+                sb.AppendLine($"def #{di}   version={def.Version}   formatChecksum=0x{def.FormatChecksum:X8}   size={def.Size}");
+
+                var enums = Resolve(def.EnumsPtr);
+                sb.AppendLine($"  enums ({enums.Length}):");
+                for (int ei = 0; ei < enums.Length; ei++)
+                {
+                    var entries = Resolve(enums[ei].EntriesPtr);
+                    sb.AppendLine($"    enum[{ei}]  ({entries.Length} entries):");
+                    foreach (var entry in entries)
+                        sb.AppendLine($"      {S(entry.StringPtr)} = {entry.Index}");
+                }
+
+                var structs = Resolve(def.StructsPtr);
+                sb.AppendLine($"  structs ({structs.Length}):");
+                for (int si = 0; si < structs.Length; si++)
+                {
+                    var st = structs[si];
+                    var props = Resolve(st.PropertiesPtr);
+                    sb.AppendLine($"    struct[{si}]  size={st.Size}  bitOffset={st.BitOffset}  ({props.Length} properties):");
+                    foreach (var prop in props)
+                        sb.AppendLine($"      +0x{prop.Offset:X}  {S(prop.NamePtr)} : {TypeString(prop.Type)}");
+                }
+
+                var indexedArrays = Resolve(def.IndexedArraysPtr);
+                if (indexedArrays.Length > 0)
+                {
+                    sb.AppendLine($"  indexedArrays ({indexedArrays.Length}):");
+                    for (int k = 0; k < indexedArrays.Length; k++)
+                    {
+                        var ia = indexedArrays[k];
+                        sb.AppendLine($"    indexedArray[{k}]  size={ia.ArraySize}  element={TypeString(ia.ElementType)}  elementSize={ia.ElementSize}");
+                    }
+                }
+
+                var enumedArrays = Resolve(def.EnumedArraysPtr);
+                if (enumedArrays.Length > 0)
+                {
+                    sb.AppendLine($"  enumedArrays ({enumedArrays.Length}):");
+                    for (int k = 0; k < enumedArrays.Length; k++)
+                    {
+                        var ea = enumedArrays[k];
+                        sb.AppendLine($"    enumArray[{k}]  enum={ea.EnumIndex}  element={TypeString(ea.ElementType)}  elementSize={ea.ElementSize}");
+                    }
+                }
+
+                sb.AppendLine($"  rootType: {TypeString(def.RootType)}");
+                sb.AppendLine();
+            }
+
+            return sb.ToString();
+        }
     }
 }

Call of Duty FastFile Editor/UI/MainWindowForm.cs

@@ -80,6 +80,11 @@ public partial class MainWindowForm : Form
         /// </summary>
         private List<StringTable> _stringTables;
 
+        /// <summary>
+        /// List of StructuredDataDef (MW2 / IW4) layout dumps extracted from the zone file.
+        /// </summary>
+        private List<StructuredDataDefAsset> _structuredDataDefs = new();
+
         /// <summary>
         /// List of tags extracted from the zone file.
         /// </summary>
@@ -666,6 +671,7 @@ private void LoadAssetRecordsData(bool forcePatternMatching = false, bool loadRa
                 _weapons = new List<WeaponAsset>();
                 _images = new List<ImageAsset>();
                 _stringTables = new List<StringTable>();
+                _structuredDataDefs = new List<StructuredDataDefAsset>();
                 _hasUnsupportedAssets = true;       // IW6 has many types we don't parse
                 _originalLocalizeCount = 0;
                 _hasUnsavedChanges = false;
@@ -696,6 +702,7 @@ private void LoadAssetRecordsData(bool forcePatternMatching = false, bool loadRa
             _weapons = loadWeapons ? (_processResult.Weapons ?? new List<WeaponAsset>()) : new List<WeaponAsset>();
             _images = loadImages ? (_processResult.Images ?? new List<ImageAsset>()) : new List<ImageAsset>();
             _stringTables = loadStringTables ? (_processResult.StringTables ?? new List<StringTable>()) : new List<StringTable>();
+            _structuredDataDefs = new List<StructuredDataDefAsset>(); // only the IW4 walk (MW2 PS3) produces these
 
             // MW2 PS3: prefer the IW4 pointer-following reader over pattern matching for every asset
             // type it walks (rawfile, localize, stringtable, weapon, techset), but only when the full
@@ -728,6 +735,7 @@ private void LoadAssetRecordsData(bool forcePatternMatching = false, bool loadRa
                         _techSets = iw4.TechSets;
                     if (loadMenuFiles && iw4.MenuLists.Count > 0)
                         _menuLists = iw4.MenuLists;
+                    _structuredDataDefs = iw4.StructuredDataDefs;
                 }
             }
 
@@ -770,6 +778,7 @@ private void LoadZoneDataToUI()
             PopulateWeapons();
             PopulateImages();
             PopulateStringTables();
+            PopulateStructuredDataDefs();
             PopulateCollision_Map_Asset_StringData();
 
             // Handle tags tab based on loadTags flag (set by LoadAssetRecordsData)
@@ -3012,6 +3021,70 @@ private void stringTablesListView_DoubleClick(object? sender, EventArgs e)
             }
         }
 
+        // Code-built "Struct Data" tab (StructuredDataDef layout dumps). Built lazily so it only
+        // appears for zones that actually have structureddatadef assets (MW2 PS3, via the IW4 walk).
+        private TabPage? _structDataTabPage;
+        private ListView? _structDataListView;
+
+        /// <summary>
+        /// Populates the Struct Data tab with the parsed StructuredDataDef layout dumps. Each row is a
+        /// DefSet; double-click opens the full layout dump (enums / structs / arrays / root type).
+        /// </summary>
+        private void PopulateStructuredDataDefs()
+        {
+            if (_structuredDataDefs == null || _structuredDataDefs.Count == 0)
+            {
+                if (_structDataTabPage != null && mainTabControl.TabPages.Contains(_structDataTabPage))
+                    mainTabControl.TabPages.Remove(_structDataTabPage);
+                return;
+            }
+
+            if (_structDataTabPage == null)
+            {
+                _structDataTabPage = new TabPage("Struct Data");
+                _structDataListView = new ListView
+                {
+                    Dock = DockStyle.Fill,
+                    View = View.Details,
+                    FullRowSelect = true,
+                    GridLines = true,
+                };
+                _structDataListView.Columns.Add("Name", 340);
+                _structDataListView.Columns.Add("Defs", 60);
+                _structDataListView.Columns.Add("Enums", 70);
+                _structDataListView.Columns.Add("Structs", 70);
+                _structDataListView.Columns.Add("Offset", 100);
+                _structDataListView.DoubleClick += structDataListView_DoubleClick;
+                _structDataTabPage.Controls.Add(_structDataListView);
+            }
+
+            if (!mainTabControl.TabPages.Contains(_structDataTabPage))
+                mainTabControl.TabPages.Add(_structDataTabPage);
+
+            _structDataListView!.Items.Clear();
+            foreach (var def in _structuredDataDefs)
+            {
+                var lvi = new ListViewItem(def.Name);
+                lvi.SubItems.Add(def.DefCount.ToString());
+                lvi.SubItems.Add(def.EnumCount.ToString());
+                lvi.SubItems.Add(def.StructCount.ToString());
+                lvi.SubItems.Add($"0x{def.Offset:X}");
+                lvi.Tag = def;
+                _structDataListView.Items.Add(lvi);
+            }
+        }
+
+        private void structDataListView_DoubleClick(object? sender, EventArgs e)
+        {
+            if (_structDataListView == null || _structDataListView.SelectedItems.Count == 0)
+                return;
+            if (_structDataListView.SelectedItems[0].Tag is StructuredDataDefAsset def)
+            {
+                using var viewer = new StructuredDataDefViewerForm(def);
+                viewer.ShowDialog(this);
+            }
+        }
+
         /// <summary>
         /// Stores the parsed collision map data for the viewer.
         /// </summary>
@@ -4380,6 +4453,7 @@ private void LoadAssetPoolIntoListView()
             int techSetIndex = 0;
             int xanimIndex = 0;
             int stringTableIndex = 0;
+            int structDataIndex = 0;
             int weaponIndex = 0;
             int imageIndex = 0;
 
@@ -4399,6 +4473,7 @@ private void LoadAssetPoolIntoListView()
                 bool isStringTable = gameDefinition.IsStringTableType(assetTypeValue);
                 bool isWeapon = gameDefinition.IsWeaponType(assetTypeValue);
                 bool isImage = gameDefinition.IsImageType(assetTypeValue);
+                bool isStructuredData = gameDefinition.IsStructuredDataDefType(assetTypeValue);
 
                 var lvi = new ListViewItem((i + 1).ToString());
                 lvi.SubItems.Add(assetTypeName);
@@ -4419,7 +4494,7 @@ private void LoadAssetPoolIntoListView()
                 // texture data, not external references. We just don't have a
                 // parser for the IW6 image struct yet.
                 string status;
-                bool isSupportedType = isRawFile || isLocalize || isMenuFile || isTechSet || isXAnim || isStringTable || isWeapon || isImage;
+                bool isSupportedType = isRawFile || isLocalize || isMenuFile || isTechSet || isXAnim || isStringTable || isWeapon || isImage || isStructuredData;
                 bool isGhosts = _openedFastFile.IsGhostsFile;
                 if (isGhosts && isImage)
                 {
@@ -4539,6 +4614,15 @@ private void LoadAssetPoolIntoListView()
                     status = $"{parseMethod} ({image.Resolution}, {image.FormattedSize})";
                     imageIndex++;
                 }
+                else if (isStructuredData && _structuredDataDefs != null && structDataIndex < _structuredDataDefs.Count)
+                {
+                    var sdd = _structuredDataDefs[structDataIndex];
+                    isParsed = true;
+                    name = string.IsNullOrEmpty(sdd.Name) ? "-" : sdd.Name;
+                    dataStart = $"0x{sdd.Offset:X}";
+                    status = $"IW4 pointer-walk ({sdd.DefCount} defs, {sdd.EnumCount} enums, {sdd.StructCount} structs)";
+                    structDataIndex++;
+                }
 
                 // Generic fallback: if no typed parser claimed this record but the
                 // walker resolved its name + body offsets (Ghosts non-rawfile types