diff --git a/UnityDataTool/Commands/analyze.md b/UnityDataTool/Commands/analyze.md new file mode 100644 index 0000000..15a6c31 --- /dev/null +++ b/UnityDataTool/Commands/analyze.md @@ -0,0 +1,136 @@ +# analyze Command + +The `analyze` command extracts information from Unity Archives (e.g. AssetBundles) and SerializedFiles and dumps the results into a SQLite database. + +## Quick Reference + +``` +UnityDataTool analyze [options] +``` + +| Option | Description | Default | +|--------|-------------|---------| +| `` | Path to folder containing files to analyze | *(required)* | +| `-o, --output-file ` | Output database filename | `database.db` | +| `-p, --search-pattern ` | File search pattern (`*` and `?` supported) | `*` | +| `-s, --skip-references` | Skip CRC and reference extraction (faster, smaller DB) | `false` | +| `-v, --verbose` | Show more information during analysis | `false` | +| `--no-recurse` | Do not recurse into sub-directories | `false` | + +## Examples + +Analyze all files in a directory: +```bash +UnityDataTool analyze /path/to/asset/bundles +``` + +Analyze only `.bundle` files and specify a custom database name: +```bash +UnityDataTool analyze /path/to/asset/bundles -o my_database.db -p "*.bundle" +``` + +Fast analysis (skip reference tracking): +```bash +UnityDataTool analyze /path/to/bundles -s +``` + +See also [Analyze Examples](../../Documentation/analyze-examples.md). + +--- + +## What Can Be Analyzed + +The analyze command works with the following types of directories: + +| Input Type | Description | +|------------|-------------| +| **AssetBundle build output** | The output path of an AssetBundle build | +| **Addressables folder** | `StreamingAssets/aa` folder from a Player build, including BuildLayout files | +| **Entities content** | `StreamingAssets/ContentArchives` folder for [Entities](https://docs.unity3d.com/Packages/com.unity.entities@1.4/manual/content-management-intro.html) projects | +| **Player Data folder** | The `Data` folder of a Unity Player build | +| **Compressed Player builds** | The `data.unity3d` file will be analyzed like AssetBundles | +| **BuildReport files** | The build report is typically found at a path like `Library/LastBuild.buildreport`and is a binary serialized file | +| **AssetDatabase Artifacts** | The tool will work to some extent with serialized files created in the AssetDatabase artifact storage, inside the Library folder | + +> **Note**: Some platforms require extracting content from platform-specific containers first (e.g., `.apk` files on Android). + +--- + +## Output Database + +The analysis creates a SQLite database that can be explored using tools like [DB Browser for SQLite](https://sqlitebrowser.org/) or the command line `sqlite3` tool. + +**Refer to the [Analyzer documentation](../../Analyzer/README.md) for the database schema reference and information about extending this command.** + +--- + +## Troubleshooting + +### File Loading Warnings + +``` +Failed to load 'C:\....\MyData.db'. File may be corrupted or was serialized with a newer version of Unity. +``` + +These warnings occur when the tool encounters non-Unity files in the analyzed directory. They are usually harmless—the analyze process continues and produces a valid database. + +**Solutions:** +- Use `-p "*.bundle"` to filter by file extension +- Use `--no-recurse` to limit directory depth +- Use `-v` (verbose) to see which files are ignored + +The tool automatically ignores common non-Unity file types (`.txt`, `.json`, `.manifest`, etc.). + +### TypeTree Errors + +``` +Error processing file: C:\...\TestProject_Data\level0 +System.ArgumentException: Invalid object id. +``` + +This error occurs when SerializedFiles are built without TypeTrees. The command will skip these files and continue. + +**Solution:** Enable **ForceAlwaysWriteTypeTrees** in your Unity build settings. See [Unity Content Format](../../Documentation/unity-content-format.md) for details. + +### SQL Constraint Errors + +``` +SQLite Error 19: 'UNIQUE constraint failed: objects.id' +``` +or +``` +SQLite Error 19: 'UNIQUE constraint failed: serialized_files.id'. +``` + +These errors occur when the same serialized file name appears in multiple sources: + +| Cause | Solution | +|-------|----------| +| Multiple builds in same directory | Analyze each build separately | +| Scenes with same filename (different paths) | Rename scenes to be unique | +| AssetBundle variants | Analyze variants separately | + +See [Comparing Builds](../../Documentation/comparing-builds.md) for strategies to compare different versions of builds. + +### Slow Analyze times, large output database + +Consider using the `--skip-references` argument. + +A real life analyze of a big Addressables build shows how large a difference this can make: + +* 208 seconds and producted a 500MB database (not specifying --skip-reference) +* 9 seconds and produced a 68 MB file (with --skip-reference) + +The references are not needed for core asset inventory and size information. + +Note: When specifying `--skip-reference` some functionality is lost: + +* the `find-refs` command will not work +* `view_material_shader_refs` and `view_material_texture_refs` will be empty +* Queries that look at the relationship between objects will not work. For example the refs table is required to link between a `MonoBehaviour` and its `MonoScript`. +* The `objects.crc32` column will be NULL/0 for all objects. This means: + * No detection of identical objects by content hash (See [Comparing Builds](../../Documentation/comparing-builds.md)) + * The `view_potential_duplicates` view relies partially on CRC32 to distinguish true duplicates + +Future work: The refs table contains a lot of repeated strings and could be made smaller and more efficient. It might also be prudent to control the CRC32 calculation using an independent flag. + diff --git a/UnityDataTool/Commands/archive.md b/UnityDataTool/Commands/archive.md new file mode 100644 index 0000000..80e59f5 --- /dev/null +++ b/UnityDataTool/Commands/archive.md @@ -0,0 +1,73 @@ +# archive Command + +The `archive` command provides utilities for working with Unity Archives (AssetBundles and web platform `.data` files). + +## Sub-Commands + +| Sub-Command | Description | +|-------------|-------------| +| [`list`](#list) | List contents of an archive | +| [`extract`](#extract) | Extract contents of an archive | + +--- + +## list + +Lists the SerializedFiles contained within an archive. + +### Quick Reference + +``` +UnityDataTool archive list +``` + +### Example + +```bash +UnityDataTool archive list scenes.bundle +``` + +--- + +## extract + +Extracts the contents of an archive to disk. This is similar to Unity's `WebExtract` tool. + +### Quick Reference + +``` +UnityDataTool archive extract [options] +``` + +| Option | Description | Default | +|--------|-------------|---------| +| `` | Path to the archive file | *(required)* | +| `-o, --output-path ` | Output directory | `archive` | + +### Example + +```bash +UnityDataTool archive extract scenes.bundle -o contents +``` + +**Output files:** +``` +contents/BuildPlayer-SampleScene.sharedAssets +contents/BuildPlayer-SampleScene +contents/BuildPlayer-Scene2.sharedAssets +contents/BuildPlayer-Scene2 +``` + +> **Note:** The extracted files are binary SerializedFiles, not text. Use the [`dump`](dump.md) command to convert them to readable text format. + +--- + +## Comparison: extract vs dump + +| Command | Output | Use Case | +|---------|--------|----------| +| `archive extract` | Binary SerializedFiles, .resS anything else inside the archive content | When you need all the raw files inside an archive | +| `dump` | text | When you want to inspect object content | + +The `dump` command can directly process archives without extracting first. + diff --git a/UnityDataTool/Commands/dump.md b/UnityDataTool/Commands/dump.md new file mode 100644 index 0000000..398775b --- /dev/null +++ b/UnityDataTool/Commands/dump.md @@ -0,0 +1,111 @@ +# dump Command + +The `dump` command converts Unity SerializedFiles into human-readable text format. This is useful for inspecting the internal structure and properties of Unity assets. + +## Quick Reference + +``` +UnityDataTool dump [options] +``` + +| Option | Description | Default | +|--------|-------------|---------| +| `` | Path to file to dump | *(required)* | +| `-o, --output-path ` | Output folder | Current folder | +| `-f, --output-format ` | Output format | `text` | +| `-s, --skip-large-arrays` | Skip dumping large arrays | `false` | +| `-i, --objectid ` | Only dump object with this ID | All objects | + +## Examples + +Dump all objects in a file to the current directory: +```bash +UnityDataTool dump /path/to/file +``` + +Dump to a specific output folder: +```bash +UnityDataTool dump /path/to/file -o /path/to/output +``` + +Dump a single object by ID: +```bash +UnityDataTool dump /path/to/file -i 1234567890 +``` + +Skip large arrays for cleaner output: +```bash +UnityDataTool dump /path/to/file -s +``` + +--- + +## Archive Support + +When you pass an Archive file (like an AssetBundle), the command dumps all SerializedFiles inside. + +**Example:** For an AssetBundle `scenes.bundle` containing two scenes: + +```bash +UnityDataTool dump scenes.bundle +``` + +**Output files:** +``` +BuildPlayer-SampleScene.sharedAssets.txt +BuildPlayer-SampleScene.txt +BuildPlayer-Scene2.sharedAssets.txt +BuildPlayer-Scene2.txt +``` + +--- + +## Output Format + +The output is similar to Unity's `binary2text` tool. Each file begins with external references: + +``` +External References +path(1): "Library/unity default resources" GUID: 0000000000000000e000000000000000 Type: 0 +path(2): "Resources/unity_builtin_extra" GUID: 0000000000000000f000000000000000 Type: 0 +path(3): "archive:/CAB-35fce856128a6714740898681ea54bbe/..." GUID: 00000000000000000000000000000000 Type: 0 +``` + +Followed by object entries: + +``` +ID: -8138362113332287275 (ClassID: 135) SphereCollider + m_GameObject PPtr + m_FileID int 0 + m_PathID SInt64 -1473921323670530447 + m_Material PPtr + m_FileID int 0 + m_PathID SInt64 0 + m_IsTrigger bool False + m_Enabled bool True + m_Radius float 0.5 + m_Center Vector3f + x float 0 + y float 0 + z float 0 +``` + +**Refer to the [TextDumper documentation](../../TextDumper/README.md) for detailed output format explanation.** + +--- + +## Understanding PPtrs + +PPtrs (Property Pointers) are Unity's mechanism for referencing objects: + +| Field | Description | +|-------|-------------| +| `m_FileID` | Index into External References list (0 = same file) | +| `m_PathID` | Object's Local File Identifier (LFID) in that file | + +A null reference will have value m_FileID = 0, m_PathID = 0 + +The external reference table is used to resolve cross-file references. It always starts at index 1. m_FileID 0 is used for references within the current file. + + + diff --git a/UnityDataTool/Commands/find-refs.md b/UnityDataTool/Commands/find-refs.md new file mode 100644 index 0000000..9f4e8fb --- /dev/null +++ b/UnityDataTool/Commands/find-refs.md @@ -0,0 +1,97 @@ +# find-refs Command + +> ⚠️ **Experimental:** This command may not work as expected in all cases. + +The `find-refs` command traces reference chains leading to specific objects. Use it to understand why an asset was included (and potentially duplicated) in a build. + +## Quick Reference + +``` +UnityDataTool find-refs [options] +``` + +| Option | Description | Default | +|--------|-------------|---------| +| `` | Path to database from `analyze` command | *(required)* | +| `-i, --object-id ` | ID of object to analyze (from `id` column) | — | +| `-n, --object-name ` | Name of objects to analyze | — | +| `-t, --object-type ` | Type filter when using `-n` | — | +| `-o, --output-file ` | Output filename | — | +| `-a, --find-all` | Find all chains instead of stopping at first | `false` | + +> **Note:** Either `--object-id` or `--object-name` must be provided. + +## Prerequisites + +This command requires a database created by the [`analyze`](analyze.md) command **without** the `--skip-references` option. + +--- + +## Examples + +Find references to an object by name and type: +```bash +UnityDataTool find-refs my_database.db -n "MyTexture" -t "Texture2D" -o refs.txt +``` + +Find references to a specific object by ID: +```bash +UnityDataTool find-refs my_database.db -i 12345 -o refs.txt +``` + +Find all duplicate references (useful for finding why an asset is duplicated): +```bash +UnityDataTool find-refs my_database.db -n "SharedMaterial" -t "Material" -a -o all_refs.txt +``` + +--- + +## Use Cases + +| Scenario | Approach | +|----------|----------| +| **Why is this asset included?** | Use `-n` with the asset name | +| **Why is this asset duplicated?** | Use `-n` to find all instances (same name, different IDs) | +| **Trace specific object** | Use `-i` with the object ID from the database | +| **Find all reference chains** | Add `-a` flag (may take longer) | + +--- + +## Output Format + +The output shows the reference chain from root assets to your target object: + +``` +Reference chains to + ID: 1234 + Type: Transform + AssetBundle: asset_bundle_name + SerializedFile: CAB-353837edf22eb1c4d651c39d27a233b7 + +Found reference in: +MyPrefab.prefab +(AssetBundle = MyAssetBundle; SerializedFile = CAB-353837edf22eb1c4d651c39d27a233b7) + GameObject (id=1348) MyPrefab + ↓ m_Component.Array[0].component + RectTransform (id=721) [Component of MyPrefab (id=1348)] + ↓ m_Children.Array[9] + RectTransform (id=1285) [Component of MyButton (id=1284)] + ↓ m_GameObject + GameObject (id=1284) MyButton + ... + Transform (id=1234) [Component of MyButtonEffectLayer (1) (id=938)] + +Analyzed 266 object(s). +Found 1 reference chain(s). +``` + +### Reading the Output + +| Element | Description | +|---------|-------------| +| `↓ property_name` | The property containing the reference | +| `[Component of X (id=Y)]` | Shows the GameObject for Components | +| `[Script = X]` | Shows the script name for MonoBehaviours | + +**Refer to the [ReferenceFinder documentation](../../ReferenceFinder/README.md) for more details.** + diff --git a/UnityDataTool/README.md b/UnityDataTool/README.md index 1a6cb14..b47c70a 100644 --- a/UnityDataTool/README.md +++ b/UnityDataTool/README.md @@ -1,227 +1,80 @@ # UnityDataTool -The UnityDataTool is a command line tool providing a set of commands related to Unity data files. It -is the main purpose of this repository. +A command-line tool for analyzing and inspecting Unity build output—AssetBundles, Player builds, Addressables, and more. -## Running UnityDataTool +## Commands -First you need to build, as described [here](../README.md#how-to-build). +| Command | Description | +|---------|-------------| +| [`analyze`](Commands/analyze.md) | Extract data from Unity files into a SQLite database | +| [`dump`](Commands/dump.md) | Convert SerializedFiles to human-readable text | +| [`archive`](Commands/archive.md) | List or extract contents of Unity Archives | +| [`find-refs`](Commands/find-refs.md) | Trace reference chains to objects *(experimental)* | -Once built, the UnityDataTools executable can be found inside `UnityDataTool/bin/[target specific folders]`. +--- -For example, on Windows the tool may be found a `[UnityDataTools repo path]\UnityDataTool\bin\Release\net9.0\UnityDataTool.exe` +## Quick Start ->[!TIP] ->Consider adding the directory that contains the UnityDataTool executable to the "Path" environmental variable on your computer. That makes it easy to invoke UnityDataTool from the command line and from other scripts, without specifying the full path every time. +```bash +# Show all commands +UnityDataTool --help -### Instructions for running on Mac +# Analyze AssetBundles into SQLite database +UnityDataTool analyze /path/to/bundles -o database.db -Note that on Mac, you need to publish the UnityDataTool project to get an executable file. You -can do it from your IDE or execute this command in the UnityDataTool folder (not from the root -folder): +# Dump a file to text format +UnityDataTool dump /path/to/file.bundle -o /output/path -(On intel-based macs) -`dotnet publish UnityDataTool -c Release -r osx-x64 -p:PublishSingleFile=true -p:UseAppHost=true` - -(On apple silicon macs) -`dotnet publish UnityDataTool -c Release -r osx-arm64 -p:PublishSingleFile=true -p:UseAppHost=true` - -Also on Mac, you may be a warning that "UnityFileSystemApi.dylib" cannot be opened because the -developer cannot be verified. In that case click "Cancel", then open the System Preferences -> Security & -Privacy window. You should be able to allow the file from there. - - -# Usage - -The tool is invoked from the command line like this: `UnityDataTool [command] [command options]` - -For a list of available commands run it like this: `UnityDataTool --help` - -For help on a specific command use `--help` along with the command name, for example: `UnityDataTool analyze --help` - -Use `UnityDataTool --version` to print the current version of the tool. - -# Commands - -## analyze/analyse - -This command extracts information from Unity Archives (e.g. AssetBundles) and SerializedFiles and dumps the results into a SQLite database. - -The command takes the path of the folder containing the files to analyze as argument. - -It also provides the following options: -* -o, --output-file \: filename of the database that will be created, the - default is database.db. Any existing file by that name will be replaced by the data from running this command. -* -s, --skip-references: skip CRC and reference (PPtrs) extraction. Faster processing and smaller - database, but inaccurate duplicate asset detection and no references table. -* -p, --search-pattern \: search pattern used to determine which files are AssetBundles. The default is \*. The * and ? characters are supported. Regular expressions are not supported. -* -v, --verbose: show more information during the analysis process, for example list any files that are ignored. -* --no-recurse: do not recurse into sub-directories. - -Example: `UnityDataTool analyze /path/to/asset/bundles -o my_database.db -p "*.bundle"` - -**Refer to this [documentation](../Analyzer/README.md#How-to-use-the-database) for more information -about the output database structure.** - - -### Example Input to the Analyze command - -Example of directories that could be analyzed: - -* The output path of an AssetBundle build. -* A folder inside the StreamingAssets folder of a Unity Player build. For example: - * The "StreamingAssets/aa" folder, containing AssetBundles from an Addressables build. - * The "StreamingAssets/ContentArchives" folder containing sub-scene content if your project uses [Entities](https://docs.unity3d.com/Packages/com.unity.entities@1.4/manual/content-management-intro.html). -* The "Data" folder of a Unity Player build. - * By default, any AssetBundles or ContentArchives in the StreamingAssets folder would also be included. Use the "--no-recurse" option to avoid that. - * Compressed Player Builds are supported. The data.unity3d file will be analyzed the same way AssetBundles are. - * The structure and content of a Player varies based on the platform. In some cases you may have to first extract the content out of a platform-specific container file prior to Analysis (for example .apk files on Android). - -### Filtering Other File Types - -Analyze works by trying to process all files in the provided path, assuming they are all Unity Archives or SerializedFiles. Because there is no standard file extension for those files it is tricky to reliably distinguish these file types from the other files that may also be found in the build output. - -This can lead to error messages in the UnityDataTool output like this: - -``` -Failed to load 'C:\....\MyData.db'. File may be corrupted or was serialized with a newer version of Unity. -``` - -Typically these are not serious errors. The analyze process will continue, and can still produce a perfectly valid database file. However if there are many messages like this it can obscure more important or unexpected failures. - -To reduce the number of these warnings, UnityDataTool automatically ignores common filenames and file paths that are found in Player, AssetBundle, Addressable or Entities builds. For example ".txt, .json, .manifest". When the `--verbose` option is passed each ignored file will be listed. - -If you use an extension or other naming convention for your AssetBundles, for example ".bundle", then you can avoid those warnings using the `-p .bundle` option to ignore other files. - -For Player builds there is no single -p option that can catch all SerializedFiles (unless it is a compressed build with a single `data.unity3d` file). - -The `--no-recurse` option can reduce the volume of these warnings. - - -### Errors when TypeTrees are missing - -If a SerializedFile is built without TypeTrees, then the Analyze command will not be able to extract information about the contained objects. It will print an error similar to this example, then skip to the next file: - -``` -Error processing file: C:\Src\TestProject\Build\Player\TestProject_Data\level0 -System.ArgumentException: Invalid object id. -``` - -See [this topic](../Documentation/unity-content-format.md) for more information about TypeTrees. - -### SQL Errors - -The following SQL errors may occur when running the analyze command: +# Extract archive contents +UnityDataTool archive extract file.bundle -o contents/ +# Find reference chains to an object +UnityDataTool find-refs database.db -n "ObjectName" -t "Texture2D" ``` -SQLite Error 19: 'UNIQUE constraint failed: objects.id' -``` - -or - -``` -SQLite Error 19: 'UNIQUE constraint failed: serialized_files.id'. -``` - -The likely cause of these errors is the same serialized file name appearing in more than Player or AssetBundle file that is processed by Analyze. - -This may occur: - -* If you analyze files from more than one version of the same build (e.g. if you run it on a directory that contains two different builds of the same project in separate sub-directories). -* If two scenes with the same filename (but different paths) are included in a build. -* In a build that used AssetBundle variants. -The conflicting name makes it impossible to uniquely identify the serialized file and its object in the database, and makes it ambiguous how to interpret dependencies from one file to another. +Use `--help` with any command for details: `UnityDataTool analyze --help` -The [comparing builds](../Documentation/comparing-builds.md) topic gives some ideas about how to run Analyze more than once if you want to compare two different versions of the same build. +Use `--version` to print the tool version. -## dump -This command dumps the contents of a SerializedFile into a file of the selected format. It currently -only supports the 'text' format, which is similar to the binary2text output format. +## Installation -The command takes the path of the file to dump as argument. It also provides the following options: -* -o, --output-path Output folder, default is the current folder. -* -f, --output-format : output format, default is 'text'. -* -s, --skip-large-arrays: the contents of basic data type arrays with a large number of elements - won't be dumped. -* -i, --objectid : only dump the object with this local file id. If not specified or 0, all objects will be dumped. +### Building -Example: `UnityDataTool dump /path/to/file -o /path/to/output` - -If you pass an Archive file to this command, it will dump the contents of all the SerializedFiles inside. - -As an example, suppose you have a AssetBundle "scenes.bundle" that contains "SampleScene.unity" and "Scene2.unity". - -Running this command: -``` -UnityDataTool dump scenes.bundle -``` - -writes out these text dumps to the current directory: +First, build the solution as described in the [main README](../README.md#how-to-build). +The executable will be at: ``` -BuildPlayer-SampleScene.sharedAssets.txt -BuildPlayer-SampleScene.txt -BuildPlayer-Scene2.sharedAssets.txt -BuildPlayer-Scene2.txt +UnityDataTool/bin/Release/net9.0/UnityDataTool.exe ``` -**Refer to this [documentation](../TextDumper/README.md#How-to-interpret-the-output-files) for more -information about the contents of the output file.** - -## archive - -The archive command offers a set of sub-commands related to Unity archives (AssetBundles and web platform .data files). +> **Tip:** Add the directory containing `UnityDataTool.exe` to your `PATH` environment variable for easy access. -**list** This sub-command lists the contents of an archive. It takes the archive path as argument. +### Mac Instructions -**extract** This sub-command extracts the contents of an archive. This is similar to the WebExtract tool that is part of the Unity installation. -It takes the archive path as argument and also accepts the following option: -* -o, --output-path \: Output directory of the extracted archive (default: archive) +On Mac, publish the project to get an executable: -As an example, suppose you have a AssetBundle "scenes.bundle" that contains "SampleScene.unity" and "Scene2.unity". - -Running this command: -``` -UnityDataTool archive extract scenes.bundle -o contents +**Intel Mac:** +```bash +dotnet publish UnityDataTool -c Release -r osx-x64 -p:PublishSingleFile=true -p:UseAppHost=true ``` -write out these 4 files: - -``` -contents/BuildPlayer-SampleScene.sharedAssets -contents/BuildPlayer-SampleScene -contents/BuildPlayer-Scene2.sharedAssets -contents/BuildPlayer-Scene2 +**Apple Silicon Mac:** +```bash +dotnet publish UnityDataTool -c Release -r osx-arm64 -p:PublishSingleFile=true -p:UseAppHost=true ``` -Note: When using this command the files are not transformed into text dumps, e.g. in this case they are the exact same binary SerializedFiles that are inside the AssetBundle. See also the `dump` command. - -## find-refs - -> Note: this is an experimental command, it may not work as expected. - -This command finds reference chains leading to specific objects. It requires a database that was -created by the 'analyze' command without the --skip-references option. It takes an object id or -name as input and will find reference chains originating from a root asset to the specified object -(s). A root asset is an asset that was explicitly added to an AssetBundle at build time. It can be -particularly useful to determine why an asset was included (and potentially more than once) in a -build. +If you see a warning about `UnityFileSystemApi.dylib` not being verified, go to **System Preferences → Security & Privacy** and allow the file. -The command takes the path of the database as argument. It also provides the following options: -* -i, --object-id \: the id of the object to analyze ('id' column in the database). -* -n, --object-name \: name of the objects to analyze (it can be useful to find the origin - of duplicates as they will have different ids but the same name). -* -t, --object-type \: type of the objects to analyze, used to filter objects when using - the -n option. -* -o, --output-file \: name of the output file. -* -a, --find-all: this will force a search for all reference chains originating from the same root. - object instead of stopping at the first one. It may take a lot more time. Note that - either --object-id or --object-name must be provided. +--- -Example: `UnityDataTool find-refs my_database.db -n "MyObjectName" -t "Texture2D" -o -references.txt` +## Related Documentation -**Refer to this [documentation](../ReferenceFinder/README.md#How-to-interpret-the-output-file) for -more information about the contents of the output file.** +| Topic | Description | +|-------|-------------| +| [Analyzer Database Reference](../Analyzer/README.md) | SQLite schema, views, and extending the analyzer | +| [TextDumper Output Format](../TextDumper/README.md) | Understanding dump output | +| [ReferenceFinder Details](../ReferenceFinder/README.md) | Reference chain output format | +| [Analyze Examples](../Documentation/analyze-examples.md) | Practical database queries | +| [Comparing Builds](../Documentation/comparing-builds.md) | Strategies for build comparison | +| [Unity Content Format](../Documentation/unity-content-format.md) | TypeTrees and file formats |