Move dump options into member variables

SkowronskiAndrew · SkowronskiAndrew · commit b9757fe048f4 · 2026-05-15T10:50:21.000-04:00
diff --git a/TextDumper/TextDumperTool.cs b/TextDumper/TextDumperTool.cs
@@ -9,7 +9,10 @@ namespace UnityDataTools.TextDumper;
 public class TextDumperTool
 {
     StringBuilder m_StringBuilder = new StringBuilder(1024);
-    bool m_SkipLargeArrays;
+    DumpOptions m_Options;
+    string m_TypeFilter;     // m_Options.TypeFilter normalized: null when blank/unset, otherwise the user-provided string
+    bool m_FilterByTypeId;   // true when m_TypeFilter parses as a ClassID (numeric)
+    int m_FilterTypeId;      // valid only when m_FilterByTypeId is true
     UnityFileReader m_Reader;
     SerializedFile m_SerializedFile;
     TextWriter m_Writer;
@@ -32,31 +35,33 @@ public class DumpOptions
 
     public int Dump(DumpOptions options)
     {
-        m_SkipLargeArrays = options.SkipLargeArrays;
+        m_Options = options;
+        m_TypeFilter = string.IsNullOrWhiteSpace(m_Options.TypeFilter) ? null : m_Options.TypeFilter;
+        m_FilterByTypeId = m_TypeFilter != null && int.TryParse(m_TypeFilter, out m_FilterTypeId);
 
         try
         {
-            if (!File.Exists(options.Path))
+            if (!File.Exists(m_Options.Path))
             {
-                Console.Error.WriteLine($"Error: File not found: {options.Path}");
+                Console.Error.WriteLine($"Error: File not found: {m_Options.Path}");
                 return 1;
             }
 
-            if (ArchiveDetector.IsUnityArchive(options.Path))
-                return DumpArchive(options);
+            if (ArchiveDetector.IsUnityArchive(m_Options.Path))
+                return DumpArchive();
 
-            if (YamlSerializedFileDetector.IsYamlSerializedFile(options.Path))
+            if (YamlSerializedFileDetector.IsYamlSerializedFile(m_Options.Path))
             {
                 Console.Error.WriteLine("Error: The file is a YAML-format SerializedFile, which is not supported.");
                 Console.Error.WriteLine("UnityDataTool only supports binary-format SerializedFiles.");
                 return 1;
             }
 
-            if (SerializedFileDetector.TryDetectSerializedFile(options.Path, out _))
-                return DumpSerializedFile(options);
+            if (SerializedFileDetector.TryDetectSerializedFile(m_Options.Path, out _))
+                return DumpSerializedFile();
 
             Console.Error.WriteLine("Error: The file does not appear to be a valid Unity SerializedFile or Unity Archive.");
-            Console.Error.WriteLine($"File: {options.Path}");
+            Console.Error.WriteLine($"File: {m_Options.Path}");
             return 1;
         }
         catch (Exception e)
@@ -67,26 +72,26 @@ public int Dump(DumpOptions options)
         }
     }
 
-    int DumpSerializedFile(DumpOptions options)
+    int DumpSerializedFile()
     {
         try
         {
-            if (options.ToStdout)
+            if (m_Options.ToStdout)
             {
                 m_Writer = Console.Out;
-                OutputSerializedFile(options.Path, options);
+                OutputSerializedFile(m_Options.Path);
                 m_Writer.Flush();
             }
             else
             {
-                using var writer = new StreamWriter(Path.Combine(options.OutputPath, Path.GetFileName(options.Path) + ".txt"), false);
+                using var writer = new StreamWriter(Path.Combine(m_Options.OutputPath, Path.GetFileName(m_Options.Path) + ".txt"), false);
                 m_Writer = writer;
-                OutputSerializedFile(options.Path, options);
+                OutputSerializedFile(m_Options.Path);
             }
         }
         catch (SerializedFileOpenException)
         {
-            var hint = SerializedFileDetector.GetOpenFailureHint(options.Path);
+            var hint = SerializedFileDetector.GetOpenFailureHint(m_Options.Path);
             if (hint != null)
             {
                 Console.Error.WriteLine();
@@ -100,11 +105,11 @@ int DumpSerializedFile(DumpOptions options)
 
     // For convenience we also support directly dumping serialized files that are inside an archive,
     // so that it's not necessary to use `archive extract` if you only want to see values from the object serialization.
-    int DumpArchive(DumpOptions options)
+    int DumpArchive()
     {
-        using var archive = UnityFileSystem.MountArchive(options.Path, "/");
+        using var archive = UnityFileSystem.MountArchive(m_Options.Path, "/");
 
-        if (options.ToStdout)
+        if (m_Options.ToStdout)
         {
             ArchiveNode? singleSerializedFile = null;
             int serializedFileCount = 0;
@@ -133,7 +138,7 @@ int DumpArchive(DumpOptions options)
             var node2 = singleSerializedFile.Value;
             Console.Error.WriteLine($"Processing {node2.Path} {node2.Size} {node2.Flags}");
             m_Writer = Console.Out;
-            OutputSerializedFile("/" + node2.Path, options);
+            OutputSerializedFile("/" + node2.Path);
             m_Writer.Flush();
         }
         else
@@ -144,24 +149,20 @@ int DumpArchive(DumpOptions options)
 
                 if (node.Flags.HasFlag(ArchiveNodeFlags.SerializedFile))
                 {
-                    using var writer = new StreamWriter(Path.Combine(options.OutputPath, Path.GetFileName(node.Path) + ".txt"), false);
+                    using var writer = new StreamWriter(Path.Combine(m_Options.OutputPath, Path.GetFileName(node.Path) + ".txt"), false);
                     m_Writer = writer;
-                    OutputSerializedFile("/" + node.Path, options);
+                    OutputSerializedFile("/" + node.Path);
                 }
             }
         }
 
         return 0;
     }
 
-    void OutputSerializedFile(string path, DumpOptions options)
+    void OutputSerializedFile(string path)
     {
-        var objectId = options.ObjectId;
-        var typeFilter = string.IsNullOrWhiteSpace(options.TypeFilter) ? null : options.TypeFilter;
-        bool filtered = objectId != 0 || typeFilter != null;
-
-        int filterTypeId = 0;
-        bool filterByTypeId = typeFilter != null && int.TryParse(typeFilter, out filterTypeId);
+        var objectId = m_Options.ObjectId;
+        bool filtered = objectId != 0 || m_TypeFilter != null;
 
         using (m_Reader = new UnityFileReader(path, 64 * 1024 * 1024))
         using (m_SerializedFile = UnityFileSystem.OpenSerializedFile(path))
@@ -190,11 +191,11 @@ void OutputSerializedFile(string path, DumpOptions options)
 
                 var root = m_SerializedFile.GetTypeTreeRoot(obj.Id);
 
-                if (typeFilter != null)
+                if (m_TypeFilter != null)
                 {
-                    if (filterByTypeId)
+                    if (m_FilterByTypeId)
                     {
-                        if (obj.TypeId != filterTypeId)
+                        if (obj.TypeId != m_FilterTypeId)
                             continue;
                     }
                     else
@@ -204,7 +205,7 @@ void OutputSerializedFile(string path, DumpOptions options)
                         // fall back to the TypeTree root node for script types.
                         if (typeName == obj.TypeId.ToString())
                             typeName = root.Type;
-                        if (!string.Equals(typeName, typeFilter, StringComparison.OrdinalIgnoreCase))
+                        if (!string.Equals(typeName, m_TypeFilter, StringComparison.OrdinalIgnoreCase))
                             continue;
                     }
                 }
@@ -217,12 +218,12 @@ void OutputSerializedFile(string path, DumpOptions options)
                 dumpedObject = true;
             }
 
-            if ((objectId != 0 || typeFilter != null) && !dumpedObject)
+            if (filtered && !dumpedObject)
             {
                 if (objectId != 0)
                     m_Writer.WriteLine($"Object with ID {objectId} not found.");
                 else
-                    m_Writer.WriteLine($"No objects found matching type \"{typeFilter}\".");
+                    m_Writer.WriteLine($"No objects found matching type \"{m_TypeFilter}\".");
             }
         }
     }
@@ -347,7 +348,7 @@ void DumpArray(TypeTreeNode node, ref long offset, int level)
             {
                 m_StringBuilder.Append(' ', (level + 1) * 2);
 
-                if (arraySize > 256 && m_SkipLargeArrays)
+                if (arraySize > 256 && m_Options.SkipLargeArrays)
                 {
                     m_StringBuilder.Append("<Skipped>");
                     offset += dataNode.Size * arraySize;

Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,10 @@ namespace UnityDataTools.TextDumper;`
`9`	`9`	`public class TextDumperTool`
`10`	`10`	`{`
`11`	`11`	`StringBuilder m_StringBuilder = new StringBuilder(1024);`
`12`		`- bool m_SkipLargeArrays;`
	`12`	`+ DumpOptions m_Options;`
	`13`	`+ string m_TypeFilter; // m_Options.TypeFilter normalized: null when blank/unset, otherwise the user-provided string`
	`14`	`+ bool m_FilterByTypeId; // true when m_TypeFilter parses as a ClassID (numeric)`
	`15`	`+ int m_FilterTypeId; // valid only when m_FilterByTypeId is true`
`13`	`16`	`UnityFileReader m_Reader;`
`14`	`17`	`SerializedFile m_SerializedFile;`
`15`	`18`	`TextWriter m_Writer;`
`@@ -32,31 +35,33 @@ public class DumpOptions`
`32`	`35`
`33`	`36`	`public int Dump(DumpOptions options)`
`34`	`37`	`{`
`35`		`- m_SkipLargeArrays = options.SkipLargeArrays;`
	`38`	`+ m_Options = options;`
	`39`	`+ m_TypeFilter = string.IsNullOrWhiteSpace(m_Options.TypeFilter) ? null : m_Options.TypeFilter;`
	`40`	`+ m_FilterByTypeId = m_TypeFilter != null && int.TryParse(m_TypeFilter, out m_FilterTypeId);`
`36`	`41`
`37`	`42`	`try`
`38`	`43`	`{`
`39`		`- if (!File.Exists(options.Path))`
	`44`	`+ if (!File.Exists(m_Options.Path))`
`40`	`45`	`{`
`41`		`- Console.Error.WriteLine($"Error: File not found: {options.Path}");`
	`46`	`+ Console.Error.WriteLine($"Error: File not found: {m_Options.Path}");`
`42`	`47`	`return 1;`
`43`	`48`	`}`
`44`	`49`
`45`		`- if (ArchiveDetector.IsUnityArchive(options.Path))`
`46`		`- return DumpArchive(options);`
	`50`	`+ if (ArchiveDetector.IsUnityArchive(m_Options.Path))`
	`51`	`+ return DumpArchive();`
`47`	`52`
`48`		`- if (YamlSerializedFileDetector.IsYamlSerializedFile(options.Path))`
	`53`	`+ if (YamlSerializedFileDetector.IsYamlSerializedFile(m_Options.Path))`
`49`	`54`	`{`
`50`	`55`	`Console.Error.WriteLine("Error: The file is a YAML-format SerializedFile, which is not supported.");`
`51`	`56`	`Console.Error.WriteLine("UnityDataTool only supports binary-format SerializedFiles.");`
`52`	`57`	`return 1;`
`53`	`58`	`}`
`54`	`59`
`55`		`- if (SerializedFileDetector.TryDetectSerializedFile(options.Path, out _))`
`56`		`- return DumpSerializedFile(options);`
	`60`	`+ if (SerializedFileDetector.TryDetectSerializedFile(m_Options.Path, out _))`
	`61`	`+ return DumpSerializedFile();`
`57`	`62`
`58`	`63`	`Console.Error.WriteLine("Error: The file does not appear to be a valid Unity SerializedFile or Unity Archive.");`
`59`		`- Console.Error.WriteLine($"File: {options.Path}");`
	`64`	`+ Console.Error.WriteLine($"File: {m_Options.Path}");`
`60`	`65`	`return 1;`
`61`	`66`	`}`
`62`	`67`	`catch (Exception e)`
`@@ -67,26 +72,26 @@ public int Dump(DumpOptions options)`
`67`	`72`	`}`
`68`	`73`	`}`
`69`	`74`
`70`		`- int DumpSerializedFile(DumpOptions options)`
	`75`	`+ int DumpSerializedFile()`
`71`	`76`	`{`
`72`	`77`	`try`
`73`	`78`	`{`
`74`		`- if (options.ToStdout)`
	`79`	`+ if (m_Options.ToStdout)`
`75`	`80`	`{`
`76`	`81`	`m_Writer = Console.Out;`
`77`		`- OutputSerializedFile(options.Path, options);`
	`82`	`+ OutputSerializedFile(m_Options.Path);`
`78`	`83`	`m_Writer.Flush();`
`79`	`84`	`}`
`80`	`85`	`else`
`81`	`86`	`{`
`82`		`- using var writer = new StreamWriter(Path.Combine(options.OutputPath, Path.GetFileName(options.Path) + ".txt"), false);`
	`87`	`+ using var writer = new StreamWriter(Path.Combine(m_Options.OutputPath, Path.GetFileName(m_Options.Path) + ".txt"), false);`
`83`	`88`	`m_Writer = writer;`
`84`		`- OutputSerializedFile(options.Path, options);`
	`89`	`+ OutputSerializedFile(m_Options.Path);`
`85`	`90`	`}`
`86`	`91`	`}`
`87`	`92`	`catch (SerializedFileOpenException)`
`88`	`93`	`{`
`89`		`- var hint = SerializedFileDetector.GetOpenFailureHint(options.Path);`
	`94`	`+ var hint = SerializedFileDetector.GetOpenFailureHint(m_Options.Path);`
`90`	`95`	`if (hint != null)`
`91`	`96`	`{`
`92`	`97`	`Console.Error.WriteLine();`
`@@ -100,11 +105,11 @@ int DumpSerializedFile(DumpOptions options)`
`100`	`105`
`101`	`106`	`// For convenience we also support directly dumping serialized files that are inside an archive,`
`102`	`107`	// so that it's not necessary to use `archive extract` if you only want to see values from the object serialization.
`103`		`- int DumpArchive(DumpOptions options)`
	`108`	`+ int DumpArchive()`
`104`	`109`	`{`
`105`		`- using var archive = UnityFileSystem.MountArchive(options.Path, "/");`
	`110`	`+ using var archive = UnityFileSystem.MountArchive(m_Options.Path, "/");`
`106`	`111`
`107`		`- if (options.ToStdout)`
	`112`	`+ if (m_Options.ToStdout)`
`108`	`113`	`{`
`109`	`114`	`ArchiveNode? singleSerializedFile = null;`
`110`	`115`	`int serializedFileCount = 0;`
`@@ -133,7 +138,7 @@ int DumpArchive(DumpOptions options)`
`133`	`138`	`var node2 = singleSerializedFile.Value;`
`134`	`139`	`Console.Error.WriteLine($"Processing {node2.Path} {node2.Size} {node2.Flags}");`
`135`	`140`	`m_Writer = Console.Out;`
`136`		`- OutputSerializedFile("/" + node2.Path, options);`
	`141`	`+ OutputSerializedFile("/" + node2.Path);`
`137`	`142`	`m_Writer.Flush();`
`138`	`143`	`}`
`139`	`144`	`else`
`@@ -144,24 +149,20 @@ int DumpArchive(DumpOptions options)`
`144`	`149`
`145`	`150`	`if (node.Flags.HasFlag(ArchiveNodeFlags.SerializedFile))`
`146`	`151`	`{`
`147`		`- using var writer = new StreamWriter(Path.Combine(options.OutputPath, Path.GetFileName(node.Path) + ".txt"), false);`
	`152`	`+ using var writer = new StreamWriter(Path.Combine(m_Options.OutputPath, Path.GetFileName(node.Path) + ".txt"), false);`
`148`	`153`	`m_Writer = writer;`
`149`		`- OutputSerializedFile("/" + node.Path, options);`
	`154`	`+ OutputSerializedFile("/" + node.Path);`
`150`	`155`	`}`
`151`	`156`	`}`
`152`	`157`	`}`
`153`	`158`
`154`	`159`	`return 0;`
`155`	`160`	`}`
`156`	`161`
`157`		`- void OutputSerializedFile(string path, DumpOptions options)`
	`162`	`+ void OutputSerializedFile(string path)`
`158`	`163`	`{`
`159`		`- var objectId = options.ObjectId;`
`160`		`- var typeFilter = string.IsNullOrWhiteSpace(options.TypeFilter) ? null : options.TypeFilter;`
`161`		`- bool filtered = objectId != 0 \|\| typeFilter != null;`
`162`		`-`
`163`		`- int filterTypeId = 0;`
`164`		`- bool filterByTypeId = typeFilter != null && int.TryParse(typeFilter, out filterTypeId);`
	`164`	`+ var objectId = m_Options.ObjectId;`
	`165`	`+ bool filtered = objectId != 0 \|\| m_TypeFilter != null;`
`165`	`166`
`166`	`167`	`using (m_Reader = new UnityFileReader(path, 64 * 1024 * 1024))`
`167`	`168`	`using (m_SerializedFile = UnityFileSystem.OpenSerializedFile(path))`
`@@ -190,11 +191,11 @@ void OutputSerializedFile(string path, DumpOptions options)`
`190`	`191`
`191`	`192`	`var root = m_SerializedFile.GetTypeTreeRoot(obj.Id);`
`192`	`193`
`193`		`- if (typeFilter != null)`
	`194`	`+ if (m_TypeFilter != null)`
`194`	`195`	`{`
`195`		`- if (filterByTypeId)`
	`196`	`+ if (m_FilterByTypeId)`
`196`	`197`	`{`
`197`		`- if (obj.TypeId != filterTypeId)`
	`198`	`+ if (obj.TypeId != m_FilterTypeId)`
`198`	`199`	`continue;`
`199`	`200`	`}`
`200`	`201`	`else`
`@@ -204,7 +205,7 @@ void OutputSerializedFile(string path, DumpOptions options)`
`204`	`205`	`// fall back to the TypeTree root node for script types.`
`205`	`206`	`if (typeName == obj.TypeId.ToString())`
`206`	`207`	`typeName = root.Type;`
`207`		`- if (!string.Equals(typeName, typeFilter, StringComparison.OrdinalIgnoreCase))`
	`208`	`+ if (!string.Equals(typeName, m_TypeFilter, StringComparison.OrdinalIgnoreCase))`
`208`	`209`	`continue;`
`209`	`210`	`}`
`210`	`211`	`}`
`@@ -217,12 +218,12 @@ void OutputSerializedFile(string path, DumpOptions options)`
`217`	`218`	`dumpedObject = true;`
`218`	`219`	`}`
`219`	`220`
`220`		`- if ((objectId != 0 \|\| typeFilter != null) && !dumpedObject)`
	`221`	`+ if (filtered && !dumpedObject)`
`221`	`222`	`{`
`222`	`223`	`if (objectId != 0)`
`223`	`224`	`m_Writer.WriteLine($"Object with ID {objectId} not found.");`
`224`	`225`	`else`
`225`		`- m_Writer.WriteLine($"No objects found matching type \"{typeFilter}\".");`
	`226`	`+ m_Writer.WriteLine($"No objects found matching type \"{m_TypeFilter}\".");`
`226`	`227`	`}`
`227`	`228`	`}`
`228`	`229`	`}`
`@@ -347,7 +348,7 @@ void DumpArray(TypeTreeNode node, ref long offset, int level)`
`347`	`348`	`{`
`348`	`349`	`m_StringBuilder.Append(' ', (level + 1) * 2);`
`349`	`350`
`350`		`- if (arraySize > 256 && m_SkipLargeArrays)`
	`351`	`+ if (arraySize > 256 && m_Options.SkipLargeArrays)`
`351`	`352`	`{`
`352`	`353`	`m_StringBuilder.Append("<Skipped>");`
`353`	`354`	`offset += dataNode.Size * arraySize;`