Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
Extract a .unitypackage to any directory (even outside the project folder) from within Unity
#define STOP_EXTRACTION_WHEN_WINDOW_CLOSED
using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using System.Text;
using System.Threading;
using UnityEditor;
using UnityEditor.IMGUI.Controls;
using UnityEngine;
public class UnitypackageExtractor : EditorWindow
{
#region Helper Classes
// Allows fetching the progress of GZipStream's decompression
// Credit: https://stackoverflow.com/a/413352/2373034
private class ProgressedFileStream : FileStream
{
private readonly UnitypackageExtractor progressTracker;
public ProgressedFileStream( UnitypackageExtractor progressTracker, string path ) : base( path, FileMode.Open, FileAccess.Read )
{
this.progressTracker = progressTracker;
}
public override int Read( byte[] buffer, int offset, int count )
{
int bytesRead = base.Read( buffer, offset, count );
progressTracker.decompressionProgressCurrent += bytesRead;
progressTracker.needsRepaint = true;
return bytesRead;
}
}
// Displays contents of a unitypackage in a tree view
private class AssetTreeView : TreeView
{
private readonly AssetTreeElement[] assets;
private readonly Dictionary<int, AssetTreeElement> idToAssetLookup = new Dictionary<int, AssetTreeElement>( 512 );
private readonly string trimmedDirectoryPath;
private readonly GUIContent sharedGUIContent = new GUIContent();
protected override bool CanMultiSelect( TreeViewItem item ) { return false; }
protected override bool CanRename( TreeViewItem item ) { return false; }
protected override void RenameEnded( RenameEndedArgs args ) { }
public AssetTreeView( TreeViewState treeViewState, AssetTreeElement[] assets, string trimmedDirectoryPath ) : base( treeViewState )
{
this.assets = assets;
this.trimmedDirectoryPath = trimmedDirectoryPath != null ? ( trimmedDirectoryPath + "/" ) : null;
showBorder = true;
#if UNITY_2019_3_OR_NEWER
depthIndentWidth += 5f;
#endif
Reload();
}
protected override TreeViewItem BuildRoot()
{
Dictionary<string, AssetTreeElement> folderAssets = new Dictionary<string, AssetTreeElement>( 64 );
Dictionary<string, TreeViewItem> directories = new Dictionary<string, TreeViewItem>( 64 );
TreeViewItem root = new TreeViewItem { id = 0, depth = -1, displayName = "Root" };
int id = 1;
for( int i = 0; i < assets.Length; i++ )
{
AssetTreeElement asset = assets[i];
if( asset.isFolder )
folderAssets[asset.path] = asset;
}
for( int i = 0; i < assets.Length; i++ )
{
AssetTreeElement asset = assets[i];
if( asset.isFolder )
continue;
// Create TreeViewItem for asset
idToAssetLookup[id] = asset;
TreeViewItem assetTreeItem = new TreeViewItem( id++, 0, asset.filename );
// Create TreeViewItem for asset's parent directory
string directoryPath = Path.GetDirectoryName( asset.path ).Replace( '\\', '/' );
TreeViewItem prevDirectory = null;
bool directoryRegisteredBefore = false;
while( !string.IsNullOrEmpty( directoryPath ) )
{
TreeViewItem directory;
if( directories.TryGetValue( directoryPath, out directory ) )
directoryRegisteredBefore = true;
else
{
AssetTreeElement folderAsset;
if( !folderAssets.TryGetValue( directoryPath, out folderAsset ) )
{
// unitypackage doesn't have a meta file for this folder, create a dummy folder holder
folderAsset = new AssetTreeElement( directoryPath, null ) { isFolder = true };
folderAssets[directoryPath] = folderAsset;
}
idToAssetLookup[id] = folderAsset;
directory = new TreeViewItem( id++, 0, folderAsset.filename );
directories[directoryPath] = directory;
}
// Don't include trimmed directories in the TreeView
bool validDirectory = trimmedDirectoryPath == null || !StartsWithFast( trimmedDirectoryPath, directoryPath + "/" );
if( validDirectory )
{
if( prevDirectory != null )
directory.AddChild( prevDirectory );
else
directory.AddChild( assetTreeItem );
prevDirectory = directory;
}
if( directoryRegisteredBefore )
{
// If this directory is trimmed (i.e. validDirectory=false), set directoryRegisteredBefore to
// false so that "else if( !directoryRegisteredBefore )" condition below is executed and
// no valid directories are excluded from the TreeView
directoryRegisteredBefore = directoryRegisteredBefore && validDirectory;
break;
}
directoryPath = Path.GetDirectoryName( directoryPath ).Replace( '\\', '/' );
}
if( prevDirectory == null )
root.AddChild( assetTreeItem );
else if( !directoryRegisteredBefore )
root.AddChild( prevDirectory );
}
// Refresh folders' extract properties
if( root.hasChildren )
{
List<TreeViewItem> rootContents = root.children;
for( int i = 0; i < rootContents.Count; i++ )
RefreshExtractDownwards( rootContents[i] );
}
SetupDepthsFromParentsAndChildren( root );
return root;
}
public HashSet<string> GetAllowedAssetGUIDs()
{
HashSet<string> result = new HashSet<string>();
bool everythingExtracted = true;
for( int i = 0; i < assets.Length; i++ )
{
if( assets[i].extract == AssetTreeElement.Extract.No )
everythingExtracted = false;
else if( !string.IsNullOrEmpty( assets[i].guid ) )
result.Add( assets[i].guid );
}
return everythingExtracted ? null : result; // We don't use HashSet when everything is extracted to improve performance
}
protected override void RowGUI( RowGUIArgs args )
{
AssetTreeElement asset = idToAssetLookup[args.item.id];
sharedGUIContent.text = asset.filename;
sharedGUIContent.image = asset.isFolder ? AssetDatabase.GetCachedIcon( "Assets" ) as Texture2D : UnityEditorInternal.InternalEditorUtility.GetIconForFile( asset.path );
Rect rect = args.rowRect;
rect.xMin += GetContentIndent( args.item );
if( asset.isFolder && asset.extract == AssetTreeElement.Extract.Mixed )
EditorGUI.showMixedValue = true;
EditorGUI.BeginChangeCheck();
bool shouldExtract = EditorGUI.Toggle( new Rect( rect.x, rect.y, rect.height, rect.height ), asset.extract == AssetTreeElement.Extract.Yes );
if( EditorGUI.EndChangeCheck() )
{
asset.extract = shouldExtract ? AssetTreeElement.Extract.Yes : AssetTreeElement.Extract.No;
if( asset.isFolder )
SetExtractDownwards( args.item, shouldExtract );
if( args.item.parent.id > 0 )
RefreshExtractUpwards( args.item.parent );
}
EditorGUI.showMixedValue = false;
rect.xMin += rect.height;
rect.y -= 2f;
rect.height += 4f; // Incrementing height fixes cropped icon issue on Unity 2019.2 or earlier
GUI.Label( rect, sharedGUIContent );
}
public void SetExtractAll( bool extract )
{
SetExtractDownwards( rootItem, extract );
}
private void SetExtractDownwards( TreeViewItem folder, bool extract )
{
if( folder.hasChildren )
{
List<TreeViewItem> folderContents = folder.children;
for( int i = 0; i < folderContents.Count; i++ )
{
AssetTreeElement folderContent = idToAssetLookup[folderContents[i].id];
folderContent.extract = extract ? AssetTreeElement.Extract.Yes : AssetTreeElement.Extract.No;
if( folderContent.isFolder )
SetExtractDownwards( folderContents[i], extract );
}
}
}
private void RefreshExtractUpwards( TreeViewItem folder )
{
AssetTreeElement _folder = idToAssetLookup[folder.id];
List<TreeViewItem> folderContents = folder.children;
AssetTreeElement.Extract extractMode = AssetTreeElement.Extract.Yes;
for( int i = 0; i < folderContents.Count; i++ )
{
AssetTreeElement folderContent = idToAssetLookup[folderContents[i].id];
if( i == 0 )
extractMode = folderContent.extract;
else if( folderContent.extract != extractMode )
{
extractMode = AssetTreeElement.Extract.Mixed;
break;
}
}
_folder.extract = extractMode;
if( folder.parent.id > 0 )
RefreshExtractUpwards( folder.parent );
}
private void RefreshExtractDownwards( TreeViewItem folder )
{
if( !folder.hasChildren )
return;
AssetTreeElement _folder = idToAssetLookup[folder.id];
List<TreeViewItem> folderContents = folder.children;
AssetTreeElement.Extract extractMode = AssetTreeElement.Extract.Yes;
for( int i = 0; i < folderContents.Count; i++ )
{
AssetTreeElement folderContent = idToAssetLookup[folderContents[i].id];
if( folderContent.isFolder )
RefreshExtractDownwards( folderContents[i] );
if( i == 0 )
extractMode = folderContent.extract;
else if( folderContent.extract != extractMode )
extractMode = AssetTreeElement.Extract.Mixed;
}
_folder.extract = extractMode;
}
}
[Serializable]
private class AssetTreeElement
{
public enum Extract { Yes = 0, No = 1, Mixed = 2 };
public string path;
public string guid;
public string filename;
public Extract extract = Extract.Yes;
public bool isFolder = false;
public AssetTreeElement( string path, string guid )
{
this.path = path;
this.guid = guid;
this.filename = Path.GetFileName( path );
}
}
#endregion
private const int BUFFER_SIZE = 4096; // Must be at least 512
private const string TRIMMED_DIRECTORY_NONE = "NONE";
private string packagePath, outputPath;
private bool isWorking, isDecompressing, isCalculatingAssetTree, needsRepaint;
private long decompressionProgressCurrent, decompressionProgressTotal;
private int renameProgressCurrent, renameProgressTotal;
private string[] trimmableDirectories;
private int trimmedDirectoryIndex = -1;
private string trimmedDirectoryPath = TRIMMED_DIRECTORY_NONE;
private bool assetDatabaseLocked;
private bool assemblyReloadLockedHint;
private Thread runningThread;
private bool abortThread;
private AssetTreeElement[] assetTree;
private AssetTreeView assetTreeView;
private TreeViewState assetTreeViewState;
private Vector2 scrollPos;
private readonly GUIContent pickFolderButtonContent = new GUIContent( "o", "Click to pick a folder. Right click to open Asset Store cache" );
private readonly GUIContent generateAssetTreeButtonContent = new GUIContent( "Select Assets to Extract...", "Select which assets to export from the unitypackage" );
[MenuItem( "Window/Unitypackage Extractor" )]
private static void Init()
{
UnitypackageExtractor window = GetWindow<UnitypackageExtractor>();
window.titleContent = new GUIContent( "Extractor" );
window.minSize = new Vector2( 300f, 100f );
window.Show();
}
private void OnEnable()
{
GenerateAssetTreeView();
}
#if STOP_EXTRACTION_WHEN_WINDOW_CLOSED
private void OnDestroy()
{
abortThread = true;
}
#endif
private void Update()
{
if( needsRepaint )
{
needsRepaint = false;
Repaint();
}
}
private void OnGUI()
{
scrollPos = GUILayout.BeginScrollView( scrollPos );
GUI.enabled = !isWorking;
float labelWidth = EditorGUIUtility.labelWidth;
EditorGUIUtility.labelWidth = 120f;
string newPackagePath = PathField( ".unitypackage Path: ", packagePath, false );
if( newPackagePath != packagePath )
{
packagePath = newPackagePath;
trimmableDirectories = null;
trimmedDirectoryIndex = -1;
trimmedDirectoryPath = TRIMMED_DIRECTORY_NONE;
assetTree = null;
assetTreeView = null;
assetTreeViewState = null;
}
outputPath = PathField( "Output Path: ", outputPath, true );
EditorGUIUtility.labelWidth = labelWidth;
if( assetTreeView != null )
{
if( trimmableDirectories != null && trimmableDirectories.Length > 0 )
{
GUILayout.BeginVertical( GUI.skin.box );
GUILayout.Label( "Trim Prefix: " + trimmedDirectoryPath, EditorStyles.boldLabel );
GUILayout.BeginHorizontal();
if( GUILayout.Toggle( trimmedDirectoryIndex == -1, "NONE", EditorStyles.toolbarButton ) && trimmedDirectoryIndex != -1 )
{
trimmedDirectoryIndex = -1;
trimmedDirectoryPath = TRIMMED_DIRECTORY_NONE;
GenerateAssetTreeView();
}
for( int i = 0; i < trimmableDirectories.Length; i++ )
{
if( GUILayout.Toggle( trimmedDirectoryIndex == i, trimmableDirectories[i], EditorStyles.toolbarButton ) && trimmedDirectoryIndex != i )
{
trimmedDirectoryIndex = i;
trimmedDirectoryPath = trimmableDirectories[0];
for( int j = 1; j <= i; j++ )
trimmedDirectoryPath += "/" + trimmableDirectories[j];
GenerateAssetTreeView();
}
}
GUILayout.EndHorizontal();
GUILayout.EndVertical();
}
GUILayout.BeginHorizontal();
GUILayout.Label( "All:" );
if( GUILayout.Button( "Select" ) )
assetTreeView.SetExtractAll( true );
if( GUILayout.Button( "Deselect" ) )
assetTreeView.SetExtractAll( false );
if( GUILayout.Button( "Expand" ) )
assetTreeView.ExpandAll();
if( GUILayout.Button( "Collapse" ) )
assetTreeView.CollapseAll();
GUILayout.EndHorizontal();
assetTreeView.OnGUI( EditorGUILayout.GetControlRect( false, assetTreeView.totalHeight ) );
EditorGUILayout.Space();
}
GUI.enabled = true;
if( !isWorking )
{
if( ( assetTree == null || assetTree.Length == 0 ) && GUILayout.Button( generateAssetTreeButtonContent ) )
{
packagePath = packagePath.Trim();
if( string.IsNullOrEmpty( packagePath ) || !File.Exists( packagePath ) )
{
Debug.LogError( ".unitypackage doesn't exist at: " + packagePath );
return;
}
ExecuteOnSeparateThread( true, false );
}
if( GUILayout.Button( "Extract!" ) )
{
packagePath = packagePath.Trim();
outputPath = outputPath.Trim();
if( outputPath.Length > 0 && ( outputPath[outputPath.Length - 1] == '/' || outputPath[outputPath.Length - 1] == '\\' ) )
outputPath = outputPath.Substring( 0, outputPath.Length - 1 );
if( string.IsNullOrEmpty( packagePath ) || !File.Exists( packagePath ) )
{
Debug.LogError( ".unitypackage doesn't exist at: " + packagePath );
return;
}
if( string.IsNullOrEmpty( outputPath ) )
{
Debug.LogError( "Output Path can't be blank" );
return;
}
if( !Directory.Exists( outputPath ) )
Directory.CreateDirectory( outputPath );
else if( Directory.GetFileSystemEntries( outputPath ).Length > 0 && !EditorUtility.DisplayDialog( "Warning", "Output Path isn't an empty folder. Conflicting files will be overridden. Proceed?", "OK", "Cancel" ) )
return;
// If we are extracting assets to this Unity project, lock AssetDatabase for safety reasons
// Assets are considered to be extracted to this Unity project if:
// a) outputPath points to the root of the Unity project directory
// b) outputPath points to either Assets folder or a subfolder of it
// In other words, if we extract the assets to PROJECT_PATH/Library or PROJECT_PATH/SomeCustomFolder, we don't have to lock AssetDatabase
string projectAbsolutePath = Path.GetFullPath( Directory.GetCurrentDirectory() ) + "/";
string outputAbsolutePath = Path.GetFullPath( outputPath ) + "/";
bool lockAssetDatabase = projectAbsolutePath == outputAbsolutePath || StartsWithFast( outputAbsolutePath, Path.GetFullPath( "Assets" ) );
if( lockAssetDatabase && !EditorUtility.DisplayDialog( "Warning", "Unitypackage will be extracted to this Unity project. To avoid any potential issues, you shouldn't modify your scenes, assets or scripts until the extraction is completed. Proceed?", "OK", "Cancel" ) )
return;
ExecuteOnSeparateThread( false, lockAssetDatabase );
}
}
else if( GUILayout.Button( "Stop" ) )
abortThread = true;
if( isWorking )
{
Rect progressbarRect = EditorGUILayout.GetControlRect( false, EditorGUIUtility.singleLineHeight );
if( isDecompressing )
{
if( decompressionProgressTotal > 0L )
EditorGUI.ProgressBar( progressbarRect, (float) ( (double) decompressionProgressCurrent / decompressionProgressTotal ), isCalculatingAssetTree ? "Generating Asset Tree" : "Decompressing Archive" );
}
else if( renameProgressTotal > 0 )
EditorGUI.ProgressBar( progressbarRect, (float) renameProgressCurrent / renameProgressTotal, string.Concat( "Renaming Assets: ", renameProgressCurrent, "/", renameProgressTotal ) );
}
GUILayout.Space( 5f );
GUILayout.EndScrollView();
}
private void GenerateAssetTreeView()
{
if( assetTree != null && assetTree.Length > 0 )
{
bool shouldExpandAll = false;
if( assetTreeViewState == null )
{
assetTreeViewState = new TreeViewState();
shouldExpandAll = true;
}
assetTreeView = new AssetTreeView( assetTreeViewState, assetTree, trimmedDirectoryIndex >= 0 ? trimmedDirectoryPath : null );
if( shouldExpandAll )
assetTreeView.ExpandAll();
}
}
private string PathField( string label, string path, bool isDirectory )
{
GUILayout.BeginHorizontal();
path = EditorGUILayout.TextField( label, path );
if( GUILayout.Button( pickFolderButtonContent, GUILayout.Width( 25f ) ) )
{
string initialPath = "";
try
{
if( Event.current.button == 1 )
{
initialPath = Environment.GetFolderPath( Environment.SpecialFolder.ApplicationData );
if( !string.IsNullOrEmpty( initialPath ) )
initialPath = Path.Combine( initialPath, "Unity/Asset Store-5.x" );
if( !Directory.Exists( initialPath ) )
initialPath = "";
}
if( string.IsNullOrEmpty( initialPath ) && !string.IsNullOrEmpty( path ) )
{
if( Directory.Exists( path ) )
initialPath = path;
else
{
string parentPath = Path.GetDirectoryName( path );
if( !string.IsNullOrEmpty( parentPath ) && Directory.Exists( parentPath ) )
initialPath = parentPath;
}
}
}
catch
{
initialPath = "";
}
string selectedPath;
if( isDirectory )
selectedPath = EditorUtility.OpenFolderPanel( "Choose output directory", initialPath, "" );
else
selectedPath = EditorUtility.OpenFilePanel( "Choose .unitypackage", initialPath, "unitypackage" );
if( !string.IsNullOrEmpty( selectedPath ) )
path = selectedPath;
GUIUtility.keyboardControl = 0; // Remove focus from active text field
}
GUILayout.EndHorizontal();
return path;
}
private void ExecuteOnSeparateThread( bool isCalculatingAssetTree, bool lockAssetDatabase )
{
abortThread = false;
isDecompressing = true;
this.isCalculatingAssetTree = isCalculatingAssetTree;
if( lockAssetDatabase )
{
AssetDatabase.StartAssetEditing();
assetDatabaseLocked = true;
}
else
assetDatabaseLocked = false;
try
{
runningThread = isCalculatingAssetTree ? new Thread( GenerateAssetTree ) : new Thread( ExtractAssets );
runningThread.Start();
scrollPos.y = 99999f; // Scroll to the bottom to see the progressbar
assemblyReloadLockedHint = false;
isWorking = true;
EditorApplication.LockReloadAssemblies();
EditorApplication.update -= UnlockAssembliesAfterExtraction;
EditorApplication.update += UnlockAssembliesAfterExtraction;
}
catch
{
if( assetDatabaseLocked )
{
AssetDatabase.StopAssetEditing();
assetDatabaseLocked = false;
}
throw;
}
}
private void UnlockAssembliesAfterExtraction()
{
if( !isWorking )
{
try
{
EditorApplication.update -= UnlockAssembliesAfterExtraction;
EditorApplication.UnlockReloadAssemblies();
if( isCalculatingAssetTree )
GenerateAssetTreeView();
}
finally
{
if( assetDatabaseLocked )
{
AssetDatabase.StopAssetEditing();
AssetDatabase.Refresh();
assetDatabaseLocked = false;
}
}
}
else
{
if( EditorApplication.isPlayingOrWillChangePlaymode )
{
EditorApplication.isPlaying = false;
Debug.LogWarning( "Can't enter Play mode while extracting a Unitypackage, <b>Stop</b> the operation first!" );
}
if( !assemblyReloadLockedHint && EditorApplication.isCompiling )
{
assemblyReloadLockedHint = true;
Debug.LogWarning( "Can't reload assemblies while extracting a Unitypackage, <b>Stop</b> the operation first!" );
}
}
}
private void GenerateAssetTree()
{
try
{
AssetTreeElement[] assetTree;
string packagePath = this.packagePath;
decompressionProgressCurrent = 0L;
decompressionProgressTotal = 0L;
using( ProgressedFileStream fs = new ProgressedFileStream( this, packagePath ) )
using( GZipStream gzip = new GZipStream( fs, CompressionMode.Decompress ) )
{
decompressionProgressTotal = fs.Length;
assetTree = GenerateAssetTreeFromTarGz( gzip );
isDecompressing = false;
}
assetTreeView = null;
this.assetTree = assetTree;
if( abortThread )
Debug.Log( "<b>Stopped generating asset tree:</b> " + packagePath );
else if( assetTree != null && assetTree.Length > 0 )
{
// Calculate trimmableDirectories
string sharedParentDirectories = null;
for( int i = 0; i < assetTree.Length; i++ )
{
AssetTreeElement asset = assetTree[i];
if( asset.isFolder )
continue;
string directoryPath = Path.GetDirectoryName( asset.path ).Replace( '\\', '/' );
// Find common parent directories of the assets in order to populate trimmableDirectories
if( sharedParentDirectories == null )
sharedParentDirectories = directoryPath;
else if( sharedParentDirectories.Length > 0 )
{
int minLength = Mathf.Min( sharedParentDirectories.Length, directoryPath.Length );
int lastPathSeparatorIndex = 0, iterator = 0;
for( ; iterator < minLength; iterator++ )
{
char ch = sharedParentDirectories[iterator];
if( ch != directoryPath[iterator] )
break;
if( ch == '/' )
lastPathSeparatorIndex = iterator;
}
if( iterator == minLength )
lastPathSeparatorIndex = iterator;
sharedParentDirectories = sharedParentDirectories.Substring( 0, lastPathSeparatorIndex );
}
}
trimmableDirectories = sharedParentDirectories.Split( '/' );
}
}
catch( Exception e )
{
Debug.LogException( e );
}
isWorking = false;
needsRepaint = true;
}
private void ExtractAssets()
{
try
{
string[] extractedDirectories;
string packagePath = this.packagePath;
string outputPath = this.outputPath;
string trimmedDirectoryPathWithSeparator = trimmedDirectoryIndex >= 0 ? ( trimmedDirectoryPath + "/" ) : null;
decompressionProgressCurrent = 0L;
decompressionProgressTotal = 0L;
renameProgressCurrent = 0;
renameProgressTotal = 0;
using( ProgressedFileStream fs = new ProgressedFileStream( this, packagePath ) )
using( GZipStream gzip = new GZipStream( fs, CompressionMode.Decompress ) )
{
decompressionProgressTotal = fs.Length;
extractedDirectories = ExtractAssetsFromTarGz( gzip, outputPath, assetTreeView != null ? assetTreeView.GetAllowedAssetGUIDs() : null );
isDecompressing = false;
}
foreach( string directory in extractedDirectories )
{
if( abortThread )
break;
string pathnameFile = Path.Combine( directory, "pathname" );
if( !File.Exists( pathnameFile ) )
continue;
string path = File.ReadAllText( pathnameFile );
int newLineIndex = path.IndexOf( '\n' );
if( newLineIndex > 0 )
path = path.Substring( 0, newLineIndex );
path = path.Trim();
// Trim common prefix directories from path, if desired
if( trimmedDirectoryPathWithSeparator != null )
{
if( path.Length < trimmedDirectoryPathWithSeparator.Length && StartsWithFast( trimmedDirectoryPathWithSeparator, path + "/" ) )
continue;
else if( StartsWithFast( path, trimmedDirectoryPathWithSeparator ) )
path = path.Substring( trimmedDirectoryPathWithSeparator.Length );
}
path = Path.Combine( outputPath, path );
Directory.CreateDirectory( Path.GetDirectoryName( path ) );
string assetFile = Path.Combine( directory, "asset" );
if( File.Exists( assetFile ) )
{
if( File.Exists( path ) )
File.Copy( assetFile, path, true );
else
File.Move( assetFile, path );
}
else // This is a directory
Directory.CreateDirectory( path );
string assetMetaFile = Path.Combine( directory, "asset.meta" );
if( File.Exists( assetMetaFile ) )
{
string metaPath = path + ".meta";
if( File.Exists( metaPath ) )
File.Copy( assetMetaFile, metaPath, true );
else
File.Move( assetMetaFile, metaPath );
}
renameProgressCurrent++;
needsRepaint = true;
}
// Cleanup temporary directories
foreach( string directory in extractedDirectories )
Directory.Delete( directory, true );
if( abortThread )
Debug.Log( "<b>Stopped extracting:</b> " + packagePath );
else
Debug.Log( "<b>Finished extracting:</b> " + packagePath );
}
catch( Exception e )
{
Debug.LogException( e );
}
isWorking = false;
needsRepaint = true;
}
// Credit: https://gist.github.com/davetransom/553aeb3c4388c3eb448c0afe564cd2e3
private AssetTreeElement[] GenerateAssetTreeFromTarGz( GZipStream input )
{
List<AssetTreeElement> assetTree = new List<AssetTreeElement>( 512 );
byte[] buffer = new byte[BUFFER_SIZE];
while( true )
{
if( abortThread )
return new AssetTreeElement[0];
input.Read( buffer, 0, 512 );
string name = Encoding.ASCII.GetString( buffer, 0, 100 ).Trim( '\0' ).Trim();
if( name.Length == 0 )
break;
else if( StartsWithFast( name, "./" ) )
{
if( name.Length == 2 )
continue;
name = name.Substring( 2 );
}
long size = Convert.ToInt64( Encoding.ASCII.GetString( buffer, 124, 12 ).Trim( '\0', ' ' ), 8 );
if( size > 0 ) // This is a file entry
{
if( Path.GetFileName( name ) == "pathname" )
{
// Fetch asset's path
using( MemoryStream memoryStream = new MemoryStream( 128 ) )
{
long remaining = size;
int bytesRead;
while( ( bytesRead = input.Read( buffer, 0, remaining >= BUFFER_SIZE ? BUFFER_SIZE : (int) remaining ) ) > 0 )
{
memoryStream.Write( buffer, 0, bytesRead );
remaining -= bytesRead;
}
string assetPath = Encoding.UTF8.GetString( memoryStream.ToArray() );
int newLineIndex = assetPath.IndexOf( '\n' );
if( newLineIndex > 0 )
assetPath = assetPath.Substring( 0, newLineIndex );
assetTree.Add( new AssetTreeElement( assetPath, Path.GetDirectoryName( name ) ) );
}
}
else
{
// Skip the file contents
long remaining = size;
int bytesRead;
while( ( bytesRead = input.Read( buffer, 0, remaining >= BUFFER_SIZE ? BUFFER_SIZE : (int) remaining ) ) > 0 )
remaining -= bytesRead;
}
}
int offset = 512 - (int) ( size % 512 );
if( offset > 0 && offset < 512 )
input.Read( buffer, 0, offset );
}
// Mark folders inside assetTree
HashSet<string> directoriesInAssetTree = new HashSet<string>();
for( int i = 0; i < assetTree.Count; i++ )
{
string directoryPath = Path.GetDirectoryName( assetTree[i].path ).Replace( '\\', '/' );
while( !string.IsNullOrEmpty( directoryPath ) )
{
if( directoriesInAssetTree.Contains( directoryPath ) )
break;
// Check if this directory's path is equal to an asset's path in assetTree
for( int j = assetTree.Count - 1; j >= 0; j-- )
{
if( assetTree[j].path == directoryPath )
assetTree[j].isFolder = true;
}
directoriesInAssetTree.Add( directoryPath );
directoryPath = Path.GetDirectoryName( directoryPath ).Replace( '\\', '/' );
}
}
assetTree.Sort( ( a1, a2 ) => a1.path.CompareTo( a2.path ) );
return assetTree.ToArray();
}
// Credit: https://gist.github.com/davetransom/553aeb3c4388c3eb448c0afe564cd2e3
private string[] ExtractAssetsFromTarGz( GZipStream input, string outputDir, HashSet<string> allowedAssetGUIDs )
{
List<string> extractedDirectories = new List<string>( 64 );
byte[] buffer = new byte[BUFFER_SIZE];
while( true )
{
if( abortThread )
return new string[0];
input.Read( buffer, 0, 512 );
string name = Encoding.ASCII.GetString( buffer, 0, 100 ).Trim( '\0' ).Trim();
if( name.Length == 0 )
break;
else if( StartsWithFast( name, "./" ) )
{
if( name.Length == 2 )
continue;
name = name.Substring( 2 );
}
long size = Convert.ToInt64( Encoding.ASCII.GetString( buffer, 124, 12 ).Trim( '\0', ' ' ), 8 );
if( size > 0 ) // This is a file entry
{
// ".icon.png": no need to extract unitypackage's thumbnail
if( ( allowedAssetGUIDs == null || allowedAssetGUIDs.Contains( Path.GetDirectoryName( name ) ) ) && name != ".icon.png" )
{
// Extract the file
string output = Path.Combine( outputDir, name );
Directory.CreateDirectory( Path.GetDirectoryName( output ) );
using( FileStream fs = File.Open( output, FileMode.OpenOrCreate, FileAccess.Write ) )
{
long remaining = size;
int bytesRead;
while( ( bytesRead = input.Read( buffer, 0, remaining >= BUFFER_SIZE ? BUFFER_SIZE : (int) remaining ) ) > 0 )
{
fs.Write( buffer, 0, bytesRead );
remaining -= bytesRead;
}
}
}
else
{
// Skip the file contents
long remaining = size;
int bytesRead;
while( ( bytesRead = input.Read( buffer, 0, remaining >= BUFFER_SIZE ? BUFFER_SIZE : (int) remaining ) ) > 0 )
remaining -= bytesRead;
}
}
else // This is a directory entry
{
if( name.Length > 1 && name[name.Length - 1] == '/' )
name = name.Substring( 0, name.Length - 1 );
if( allowedAssetGUIDs == null || allowedAssetGUIDs.Contains( name ) )
{
// After extraction, contents of each directory will be renamed to match the target asset's name
renameProgressTotal++;
extractedDirectories.Add( Path.Combine( outputDir, name ) );
}
}
int offset = 512 - (int) ( size % 512 );
if( offset > 0 && offset < 512 )
input.Read( buffer, 0, offset );
}
for( int i = extractedDirectories.Count - 1; i >= 0; i-- )
{
if( !Directory.Exists( extractedDirectories[i] ) )
extractedDirectories.RemoveAt( i );
}
return extractedDirectories.ToArray();
}
// Returns true is str starts with prefix
private static bool StartsWithFast( string str, string prefix )
{
int aLen = str.Length;
int bLen = prefix.Length;
int ap = 0; int bp = 0;
while( ap < aLen && bp < bLen && str[ap] == prefix[bp] )
{
ap++;
bp++;
}
return bp == bLen;
}
}
@yasirkula

This comment has been minimized.

Copy link
Owner Author

@yasirkula yasirkula commented Mar 17, 2020

How To

Simply create a folder called Editor inside your Project window and add this script inside it. Then, open Window-Unitypackage Extractor, configure the parameters and hit "Extract!". The operation will be handled by a separate thread, so it won't block Unity.

If you don't want to extract all assets inside the .unitypackage, hit "Select Assets to Extract..." first.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment