Read objectlist out of metadata section

Author: SkowronskiAndrew

Analyzer.Tests/FileDetectionTests.cs

@@ -410,6 +410,44 @@ public void TryParseMetadata_V23ExtractedMonoscriptBundle_ReturnsExpectedTypeTre
         }
     }
 
+    [Test]
+    public void TryParseMetadata_V22PrefabWithSerializedReference_ReturnsExpectedObjectList()
+    {
+        var testFile = Path.Combine(m_TestDataPath, "AssetBundleTypeTreeVariations", "v22",
+            "prefab_with_serializedreference.serializedfile");
+
+        bool headerResult = SerializedFileDetector.TryDetectSerializedFile(testFile, out var headerInfo);
+        Assert.IsTrue(headerResult, "File should be detected as a valid SerializedFile");
+
+        bool result = SerializedFileDetector.TryParseMetadata(testFile, headerInfo, out var metadata, out var errorMessage);
+        Assert.IsTrue(result, $"Metadata parsing should succeed. Error: {errorMessage}");
+        Assert.IsNotNull(metadata);
+
+        Assert.IsNotNull(metadata.ObjectList, "ObjectList should be populated");
+        Assert.That(metadata.ObjectList.Length, Is.EqualTo(6), "Should have 6 objects");
+
+        // Verify exact values for each object entry.
+        // Expected data from the file's object table (fileID, typeID, offset, size):
+        var expected = new (long Id, int TypeId, long Offset, long Size)[]
+        {
+            (                   1L, 142,  5552L, 300L),  // AssetBundle
+            ( 674343093664966924L,   4,  5856L,  68L),  // Transform
+            (4902368549205534988L,   4,  5936L,  80L),  // Transform
+            (5206304541755795724L,   1,  6016L,  51L),  // GameObject
+            (6854740422901983500L,   1,  6080L,  35L),  // GameObject
+            (8430482813342345484L, 114,  6128L, 104L),  // MonoBehaviour
+        };
+
+        for (int i = 0; i < expected.Length; i++)
+        {
+            var obj = metadata.ObjectList[i];
+            Assert.That(obj.Id,     Is.EqualTo(expected[i].Id),     $"ObjectList[{i}].Id");
+            Assert.That(obj.TypeId, Is.EqualTo(expected[i].TypeId), $"ObjectList[{i}].TypeId");
+            Assert.That(obj.Offset, Is.EqualTo(expected[i].Offset), $"ObjectList[{i}].Offset");
+            Assert.That(obj.Size,   Is.EqualTo(expected[i].Size),   $"ObjectList[{i}].Size");
+        }
+    }
+
     #endregion
 
     #region YAML SerializedFile Detection Tests

Analyzer/Util/BinaryFileHelper.cs

@@ -67,6 +67,18 @@ public static uint ReadUInt32(BinaryReader reader, bool swap)
         return swap ? SwapUInt32(raw) : raw;
     }
 
+    public static ulong ReadUInt64(BinaryReader reader, bool swap)
+    {
+        ulong raw = reader.ReadUInt64();
+        return swap ? SwapUInt64(raw) : raw;
+    }
+
+    public static long ReadInt64(BinaryReader reader, bool swap)
+    {
+        ulong raw = reader.ReadUInt64();
+        return (long)(swap ? SwapUInt64(raw) : raw);
+    }
+
     public static UnityHash128 ReadHash128(BinaryReader reader, bool swap)
     {
         return new UnityHash128

Analyzer/Util/SerializedFileDetector.cs

@@ -1,5 +1,6 @@
 using System;
 using System.IO;
+using ObjectInfo = UnityDataTools.FileSystem.ObjectInfo;
 
 namespace UnityDataTools.Analyzer.Util;
 
@@ -166,6 +167,12 @@ public class SerializedFileMetadata
     /// Empty array for files with version < 20.
     /// </summary>
     public TypeTreeInfo[] SerializedReferenceTypeTrees { get; set; }
+
+    /// <summary>
+    /// List of all objects recorded in the file's object table.
+    /// Null until the metadata section has been parsed.
+    /// </summary>
+    public ObjectInfo[] ObjectList { get; set; }
 }
 
 /// <summary>
@@ -567,28 +574,41 @@ private static void ParseExtendedMetadata(BinaryReader reader, SerializedFileInf
                 typeTrees[i] = ReadTypeEntry(reader, version, swap, isRefType: false, enableTypeTree);
             metadata.TypeTrees = typeTrees;
 
-            // m_RefTypes (version >= 20) is not located immediately after m_Types.
-            // It appears at the end of the metadata section, after the object list,
-            // script type list, and externals list. We must skip those three sections.
-            if (version < SupportsRefObjectVersion)
-                return;
-
-            // --- Skip the object list ---
+            // --- Object list ---
             // Per-object layout (version >= 19):
             //   [4-byte alignment relative to metadata start]
             //   [int64  fileID]
             //   [uint32 byteStart]  or  [uint64 byteStart]  (version >= 22)
             //   [uint32 byteSize]
             //   [uint32 typeID]
             int objectCount = BinaryFileHelper.ReadInt32(reader, swap);
+            var objectList = new ObjectInfo[objectCount];
             for (int i = 0; i < objectCount; i++)
             {
                 BinaryFileHelper.AlignTo4(stream, metadataOffset);
-                stream.Seek(8, SeekOrigin.Current); // int64 fileID
-                stream.Seek(version >= LargeFilesSupportVersion ? 8 : 4, SeekOrigin.Current); // byteStart
-                stream.Seek(4, SeekOrigin.Current); // uint32 byteSize
-                stream.Seek(4, SeekOrigin.Current); // uint32 typeID
+                long fileID = BinaryFileHelper.ReadInt64(reader, swap);
+                // byteStart is relative to the data section; add DataOffset to get the absolute file offset,
+                // matching the behaviour of the native DLL which returns the absolute offset in ObjectInfo.Offset.
+                long byteStart = version >= LargeFilesSupportVersion
+                    ? (long)BinaryFileHelper.ReadUInt64(reader, swap)
+                    : BinaryFileHelper.ReadUInt32(reader, swap);
+                byteStart += (long)headerInfo.DataOffset;
+                long byteSize = BinaryFileHelper.ReadUInt32(reader, swap);
+                // typeIndex is a 0-based index into the m_Types array, not the persistent type ID.
+                // Resolve it to the persistent type ID to match the behaviour of the native DLL.
+                int typeIndex = BinaryFileHelper.ReadInt32(reader, swap);
+                int persistentTypeID = (typeIndex >= 0 && typeIndex < typeTrees.Length)
+                    ? typeTrees[typeIndex].PersistentTypeID
+                    : typeIndex;
+                objectList[i] = new ObjectInfo(fileID, byteStart, byteSize, persistentTypeID);
             }
+            metadata.ObjectList = objectList;
+
+            // m_RefTypes (version >= 20) is not located immediately after m_Types.
+            // It appears at the end of the metadata section, after the object list,
+            // script type list, and externals list. We must skip those three sections.
+            if (version < SupportsRefObjectVersion)
+                return;
 
             // --- Skip the script type list ---
             // Per-entry layout (version >= 14, applies to all our versions):

UnityFileSystem/DllWrapper.cs

@@ -119,6 +119,14 @@ public struct ObjectInfo
     public readonly long Offset;
     public readonly long Size;
     public readonly int TypeId;
+
+    public ObjectInfo(long id, long offset, long size, int typeId)
+    {
+        Id = id;
+        Offset = offset;
+        Size = size;
+        TypeId = typeId;
+    }
 }
 [Flags]
 public enum TypeTreeFlags