private List <string> GetAssetsReferencedFromAssemblyDefinition(string assetPath)
{
var result = new List <string>();
var asset = AssetDatabase.LoadAssetAtPath <UnityEditorInternal.AssemblyDefinitionAsset>(assetPath);
var data = JsonUtility.FromJson <AssemblyDefinitionData>(asset.text);
if (data.references != null && data.references.Length > 0)
{
foreach (var reference in data.references)
{
#if !UNITY_2019_1_OR_NEWER
var assemblyDefinitionFilePathFromAssemblyName = CompilationPipeline.GetAssemblyDefinitionFilePathFromAssemblyName(reference);
#else
var assemblyDefinitionFilePathFromAssemblyName = CompilationPipeline.GetAssemblyDefinitionFilePathFromAssemblyReference(reference);
#endif
if (!string.IsNullOrEmpty(assemblyDefinitionFilePathFromAssemblyName))
{
assemblyDefinitionFilePathFromAssemblyName = CSPathTools.EnforceSlashes(assemblyDefinitionFilePathFromAssemblyName);
result.Add(assemblyDefinitionFilePathFromAssemblyName);
}
}
}
data.references = null;
return(result);
}
protected override void ConstructBody(StringBuilder text)
{
text.Append(Location == RecordLocation.Scene ? "<b>Scene:</b> " : "<b>Prefab:</b> ");
var nicePath = CSPathTools.NicifyAssetPath(Path, true);
text.Append(nicePath);
if (!string.IsNullOrEmpty(transformPath))
{
text.Append("\n<b>Object:</b> ").Append(transformPath);
}
if (!string.IsNullOrEmpty(componentName))
{
text.Append("\n<b>Component:</b> ").Append(componentName);
}
if (!string.IsNullOrEmpty(componentNamePostfix))
{
text.Append(componentNamePostfix);
}
if (!string.IsNullOrEmpty(propertyPath))
{
var propertyName = CSObjectTools.GetNicePropertyPath(propertyPath);
text.Append("\n<b>Property:</b> ").Append(propertyName);
}
}
private List <string> GetAssetsReferencedFromAssemblyDefinitionReference(string assetPath)
{
var result = new List <string>();
var asset = AssetDatabase.LoadAssetAtPath <UnityEditorInternal.AssemblyDefinitionReferenceAsset>(assetPath);
var data = JsonUtility.FromJson <AssemblyDefinitionReferenceData>(asset.text);
if (!string.IsNullOrEmpty(data.reference))
{
var assemblyDefinitionPath = CompilationPipeline.GetAssemblyDefinitionFilePathFromAssemblyReference(data.reference);
if (!string.IsNullOrEmpty(assemblyDefinitionPath))
{
assemblyDefinitionPath = CSPathTools.EnforceSlashes(assemblyDefinitionPath);
var guid = AssetDatabase.AssetPathToGUID(assemblyDefinitionPath);
if (!string.IsNullOrEmpty(guid))
{
result.Add(guid);
}
}
}
data.reference = null;
return(result);
}
public static void ScanShaderForNestedFallbacks(List <string> referencePaths, string shaderPath)
{
var shaderCode = new StringBuilder();
using (var sr = File.OpenText(shaderPath))
{
string s;
while ((s = sr.ReadLine()) != null)
{
shaderCode.AppendLine(s);
}
}
var shaderCodeString = shaderCode.ToString();
var lastIndex = 0;
while (lastIndex != -1)
{
lastIndex = shaderCodeString.IndexOf("fallback", lastIndex + 1, StringComparison.CurrentCultureIgnoreCase);
if (lastIndex != -1)
{
var firstQuoteIndex = shaderCodeString.IndexOf('"', lastIndex);
if (firstQuoteIndex == -1)
{
continue;
}
var whiteSpace = shaderCodeString.Substring(lastIndex + 8, firstQuoteIndex - (lastIndex + 8));
whiteSpace = whiteSpace.Trim();
if (whiteSpace.Length != 0)
{
continue;
}
var lastQuoteIndex = shaderCodeString.IndexOf('"', firstQuoteIndex + 1);
if (lastQuoteIndex == -1)
{
continue;
}
var fallbackName = shaderCodeString.Substring(firstQuoteIndex + 1, lastQuoteIndex - firstQuoteIndex - 1);
var fallbackShader = Shader.Find(fallbackName);
var fallbackShaderPath = CSPathTools.EnforceSlashes(AssetDatabase.GetAssetPath(fallbackShader));
if (!fallbackShaderPath.StartsWith("Assets", StringComparison.Ordinal))
{
continue;
}
if (referencePaths.IndexOf(fallbackShaderPath) == -1)
{
referencePaths.Add(fallbackShaderPath);
ScanFileForIncludes(referencePaths, fallbackShaderPath);
}
ScanShaderForNestedFallbacks(referencePaths, fallbackShaderPath);
}
}
}
protected AssetRecord(string folderPath) : base(RecordType.EmptyFolder, RecordLocation.Asset)
{
path = folderPath;
assetDatabasePath = !Path.IsPathRooted(folderPath) ? folderPath : folderPath.Substring(CSPathTools.assetsFolderIndex + 1);
beautyPath = CSPathTools.NicifyAssetPath(assetDatabasePath);
}
private static bool ScanFolders(ICollection <CleanerRecord> results, bool showProgress = true)
{
bool canceled;
currentPhase++;
folderIndex = 0;
if (showProgress)
{
EditorUtility.DisplayProgressBar(
string.Format(ProgressCaption, currentPhase, phasesCount, folderIndex, foldersCount), "Getting all folders...", (float)folderIndex / foldersCount);
}
var emptyFolders = new List <string>();
var root = CSPathTools.EnforceSlashes(Application.dataPath);
foldersCount = Directory.GetDirectories(root, "*", SearchOption.AllDirectories).Length;
FindEmptyFoldersRecursive(emptyFolders, root, showProgress, out canceled);
ExcludeSubFoldersOfEmptyFolders(ref emptyFolders);
foreach (var folder in emptyFolders)
{
var newRecord = AssetRecord.CreateEmptyFolderRecord(folder);
if (newRecord != null)
{
results.Add(newRecord);
}
}
return(canceled);
}
private List <string> GetGetAssetsInFoldersReferencedFromSpriteAtlas(string assetPath)
{
var result = new List <string>();
var asset = AssetDatabase.LoadAssetAtPath <UnityEngine.U2D.SpriteAtlas>(assetPath);
var so = new SerializedObject(asset);
// source: SpriteAtlasInspector
var packablesProperty = so.FindProperty("m_EditorData.packables");
if (packablesProperty == null || !packablesProperty.isArray)
{
Debug.LogError(Maintainer.LogPrefix + "Can't parse UnityEngine.U2D.SpriteAtlas, please report to " + Maintainer.SupportEmail);
}
else
{
var count = packablesProperty.arraySize;
for (var i = 0; i < count; i++)
{
var packable = packablesProperty.GetArrayElementAtIndex(i);
var objectReferenceValue = packable.objectReferenceValue;
if (objectReferenceValue != null)
{
var path = AssetDatabase.GetAssetOrScenePath(objectReferenceValue);
if (AssetDatabase.IsValidFolder(path))
{
var packablePaths = CSPathTools.GetAllPackableAssetsPathsRecursive(path);
result.AddRange(packablePaths);
}
}
}
}
return(result);
}
protected AssetRecord(string folderPath) : base(RecordType.EmptyFolder, RecordLocation.Asset)
{
path = folderPath;
assetDatabasePath = CSPathTools.GetProjectRelativePath(folderPath);
beautyPath = CSPathTools.NicifyAssetPath(assetDatabasePath);
}
internal override void ProcessDrags()
{
if (currentEventType != EventType.DragUpdated && currentEventType != EventType.DragPerform)
{
return;
}
var paths = DragAndDrop.paths;
if (paths != null && paths.Length > 0)
{
var canDrop = false;
for (var i = 0; i < paths.Length; i++)
{
paths[i] = CSPathTools.EnforceSlashes(paths[i]);
if (LooksLikeSceneFile(paths[i]))
{
canDrop = true;
break;
}
}
if (canDrop)
{
DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
if (currentEventType == EventType.DragPerform)
{
var needToSave = false;
var needToShowWarning = false;
foreach (var path in paths)
{
if (LooksLikeSceneFile(path))
{
var added = CSFilterTools.TryAddNewItemToFilters(ref filters, FilterItem.Create(path, FilterKind.Path));
needToSave |= added;
needToShowWarning |= !added;
}
}
if (needToSave)
{
SaveChanges();
}
if (needToShowWarning)
{
window.ShowNotification(new GUIContent("One or more of the dragged items already present in the list!"));
}
DragAndDrop.AcceptDrag();
}
}
}
Event.current.Use();
}
protected override void ConstructBody(StringBuilder text)
{
text.AppendLine("<b>Scene: </b>" + CSPathTools.NicifyAssetPath(Path, true));
text.Append("<b>Settings: </b>" + SettingsKind);
if (!string.IsNullOrEmpty(PropertyPath))
{
var propertyName = CSObjectTools.GetNicePropertyPath(PropertyPath);
text.Append("\n<b>Property:</b> ").Append(propertyName);
}
}
protected override bool CheckNewItem(ref string newItem)
{
newItem = CSPathTools.EnforceSlashes(newItem);
if (LooksLikeSceneFile(newItem))
{
return(true);
}
EditorUtility.DisplayDialog("Can't find specified scene", "Scene " + newItem + " wasn't found in project. Make sure you've entered relative path starting from Assets/.", "Cool, thanks!");
return(false);
}
internal override void ProcessDrags()
{
if (currentEventType != EventType.DragUpdated && currentEventType != EventType.DragPerform)
{
return;
}
var paths = DragAndDrop.paths;
var objectReferences = DragAndDrop.objectReferences;
if (paths != null && objectReferences != null && paths.Length > 0 && paths.Length == objectReferences.Length)
{
var atLeastOneFileAsset = objectReferences.Any(AssetDatabase.Contains);
if (!atLeastOneFileAsset)
{
return;
}
DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
if (currentEventType == EventType.DragPerform)
{
for (var i = 0; i < objectReferences.Length; i++)
{
paths[i] = CSPathTools.EnforceSlashes(AssetDatabase.GetAssetPath(objectReferences[i]));
}
var needToSave = false;
var needToShowWarning = false;
foreach (var path in paths)
{
var added = CSFilterTools.TryAddNewItemToFilters(ref filters, FilterItem.Create(path, FilterKind.Path));
needToSave |= added;
needToShowWarning |= !added;
}
if (needToSave)
{
SaveChanges();
}
if (needToShowWarning)
{
window.ShowNotification(new GUIContent("One or more of the dragged items already present in the list!"));
}
DragAndDrop.AcceptDrag();
}
}
Event.current.Use();
}
protected override void ConstructBody(StringBuilder text)
{
text.Append("<b>Scriptable Object:</b> ");
text.Append(CSPathTools.NicifyAssetPath(Path, true));
if (!string.IsNullOrEmpty(typeName))
{
text.Append("\n<b>Type:</b>").Append(typeName);
}
if (!string.IsNullOrEmpty(propertyPath))
{
var propertyName = CSObjectTools.GetNicePropertyPath(propertyPath);
text.Append("\n<b>Property:</b> ").Append(propertyName);
}
}
private void ActualizePath()
{
if (Kind == AssetKind.FromPackage)
{
return;
}
var actualPath = CSPathTools.EnforceSlashes(AssetDatabase.GUIDToAssetPath(GUID));
if (!string.IsNullOrEmpty(actualPath) && actualPath != Path)
{
fileInfo = new FileInfo(actualPath);
metaFileInfo = new FileInfo(actualPath + ".meta");
Path = actualPath;
}
}
internal AssetRecord(RecordType type, AssetInfo assetInfo) : base(type, RecordLocation.Asset)
{
path = assetInfo.Path;
assetDatabasePath = CSPathTools.GetPathRelativeToProject(path);
beautyPath = CSPathTools.NicifyAssetPath(assetDatabasePath);
assetType = assetInfo.Type;
if (assetType != null && assetType.BaseType == CSReflectionTools.textureType)
{
isTexture = true;
}
if (type == RecordType.UnreferencedAsset)
{
size = assetInfo.Size;
}
}
internal static string[] GetSelectedAssets(int[] instanceIDs)
{
var paths = new List <string>(instanceIDs.Length);
foreach (var id in instanceIDs)
{
if (AssetDatabase.IsSubAsset(id))
{
continue;
}
var path = AssetDatabase.GetAssetPath(id);
path = CSPathTools.EnforceSlashes(path);
if (!File.Exists(path) && !Directory.Exists(path))
{
continue;
}
paths.Add(path);
}
return(paths.ToArray());
}
private static void FillSettingsAssetDependencies(ref HashSet <string> dependenciesGUIDs, string assetPath, AssetSettingsKind settingsKind)
{
if (settingsKind == AssetSettingsKind.EditorBuildSettings)
{
var scenesInBuildGUIDs = CSSceneTools.GetScenesInBuildGUIDs(true);
if (scenesInBuildGUIDs != null)
{
dependenciesGUIDs.UnionWith(scenesInBuildGUIDs);
}
}
else
{
var settingsAsset = AssetDatabase.LoadAllAssetsAtPath(assetPath);
if (settingsAsset != null && settingsAsset.Length > 0)
{
var settingsAssetSerialized = new SerializedObject(settingsAsset[0]);
var sp = settingsAssetSerialized.GetIterator();
while (sp.Next(true))
{
if (sp.propertyType == SerializedPropertyType.ObjectReference)
{
var instanceId = sp.objectReferenceInstanceIDValue;
if (instanceId != 0)
{
var path = CSPathTools.EnforceSlashes(AssetDatabase.GetAssetPath(instanceId));
if (!string.IsNullOrEmpty(path) && path.StartsWith("Assets"))
{
var guid = AssetDatabase.AssetPathToGUID(path);
if (!string.IsNullOrEmpty(guid))
{
dependenciesGUIDs.Add(guid);
}
}
}
}
}
}
}
}
private static string[] GetAssetsReferencedInPlayerSettingsAsset(string assetPath, AssetSettingsKind settingsKind)
{
var referencedAssets = new List <string>();
if (settingsKind == AssetSettingsKind.EditorBuildSettings)
{
referencedAssets.AddRange(CSSceneTools.GetScenesInBuild(true));
}
else
{
var settingsAsset = AssetDatabase.LoadAllAssetsAtPath(assetPath);
if (settingsAsset != null && settingsAsset.Length > 0)
{
var settingsAssetSerialized = new SerializedObject(settingsAsset[0]);
var sp = settingsAssetSerialized.GetIterator();
while (sp.Next(true))
{
if (sp.propertyType == SerializedPropertyType.ObjectReference)
{
var instanceId = sp.objectReferenceInstanceIDValue;
if (instanceId != 0)
{
var path = CSPathTools.EnforceSlashes(AssetDatabase.GetAssetPath(instanceId));
if (!string.IsNullOrEmpty(path) && path.StartsWith("Assets"))
{
if (referencedAssets.IndexOf(path) == -1)
{
referencedAssets.Add(path);
}
}
}
}
}
}
}
return(referencedAssets.ToArray());
}
private static void ExcludeSubFoldersOfEmptyFolders(ref List <string> emptyFolders)
{
var emptyFoldersFiltered = new List <string>(emptyFolders.Count);
for (var i = emptyFolders.Count - 1; i >= 0; i--)
{
var folder = emptyFolders[i];
if (CSFilterTools.HasEnabledFilters(ProjectSettings.Cleaner.pathIncludesFilters))
{
var emptyFolder = CSPathTools.GetProjectRelativePath(folder);
if (!CSFilterTools.IsValueMatchesAnyFilter(emptyFolder, ProjectSettings.Cleaner.pathIncludesFilters))
{
continue;
}
}
if (!CSArrayTools.IsItemContainsAnyStringFromArray(folder, emptyFoldersFiltered))
{
emptyFoldersFiltered.Add(folder);
}
}
emptyFolders = emptyFoldersFiltered;
}
private static bool FindEmptyFoldersRecursive(List <string> foundEmptyFolders, string root, bool showProgress, out bool canceledByUser)
{
var rootSubFolders = Directory.GetDirectories(root);
var canceled = false;
var emptySubFolders = true;
var count = rootSubFolders.Length;
var updateStep = Math.Max(count / MaintainerSettings.UpdateProgressStep, 1);
for (var i = 0; i < count; i++)
{
var folder = CSPathTools.EnforceSlashes(rootSubFolders[i]);
folderIndex++;
if (showProgress && (i % updateStep == 0) && EditorUtility.DisplayCancelableProgressBar(
string.Format(ProgressCaption, currentPhase, phasesCount, folderIndex, foldersCount), "Scanning folders...",
(float)folderIndex / foldersCount))
{
canceled = true;
break;
}
if (CSFilterTools.IsValueMatchesAnyFilter(folder.Replace('\\', '/'), MaintainerSettings.Cleaner.pathIgnoresFilters))
{
emptySubFolders = false;
continue;
}
emptySubFolders &= FindEmptyFoldersRecursive(foundEmptyFolders, folder, showProgress, out canceled);
if (canceled)
{
break;
}
}
if (canceled)
{
canceledByUser = true;
return(false);
}
var rootFolderHasFiles = true;
var filesInRootFolder = Directory.GetFiles(root);
foreach (var file in filesInRootFolder)
{
if (file.EndsWith(".meta", StringComparison.OrdinalIgnoreCase))
{
continue;
}
rootFolderHasFiles = false;
break;
}
var rootFolderEmpty = emptySubFolders && rootFolderHasFiles;
if (rootFolderEmpty)
{
foundEmptyFolders.Add(root);
}
canceledByUser = false;
return(rootFolderEmpty);
}
protected override bool PerformClean()
{
bool result;
if (ProjectSettings.Cleaner.useTrashBin)
{
result = AssetDatabase.MoveAssetToTrash(assetDatabasePath);
}
else
{
switch (type)
{
case RecordType.EmptyFolder:
{
if (Directory.Exists(path))
{
Directory.Delete(path, true);
}
break;
}
case RecordType.UnreferencedAsset:
{
CSFileTools.DeleteFile(path);
break;
}
case RecordType.Error:
break;
case RecordType.Other:
break;
default:
throw new ArgumentOutOfRangeException();
}
var metaPath = path + ".meta";
CSFileTools.DeleteFile(metaPath);
result = !(Directory.Exists(path) || File.Exists(path));
}
if (!result)
{
Debug.LogWarning(Maintainer.LogPrefix + ProjectCleaner.ModuleName + " can't clean asset: " + beautyPath);
}
else
{
var directory = CSPathTools.EnforceSlashes(Path.GetDirectoryName(path));
if (!string.IsNullOrEmpty(directory) && Directory.Exists(directory))
{
var filesInDir = Directory.GetFiles(directory, "*", SearchOption.TopDirectoryOnly);
if (filesInDir.Length == 0)
{
CreateEmptyFolderRecord(directory).Clean();
}
}
}
return(result);
}
public void UpdateIfNeeded()
{
if (string.IsNullOrEmpty(Path))
{
Debug.LogWarning(Maintainer.LogPrefix + "Can't update Asset since path is not set!");
return;
}
/*if (Path.Contains("qwerty.unity"))
* {
* Debug.Log(Path);
* }*/
fileInfo.Refresh();
if (!fileInfo.Exists)
{
Debug.LogWarning(Maintainer.LogPrefix + "Can't update asset since file at path is not found:\n" + fileInfo.FullName + "\nAsset Path: " + Path);
return;
}
ulong currentHash = 0;
if (metaFileInfo == null)
{
metaFileInfo = new FileInfo(fileInfo.FullName + ".meta");
}
metaFileInfo.Refresh();
if (metaFileInfo.Exists)
{
currentHash += (ulong)metaFileInfo.LastWriteTimeUtc.Ticks;
currentHash += (ulong)metaFileInfo.Length;
}
currentHash += (ulong)fileInfo.LastWriteTimeUtc.Ticks;
currentHash += (ulong)fileInfo.Length;
if (lastHash == currentHash)
{
for (var i = dependenciesGUIDs.Length - 1; i > -1; i--)
{
var guid = dependenciesGUIDs[i];
var path = AssetDatabase.GUIDToAssetPath(guid);
path = CSPathTools.EnforceSlashes(path);
if (!string.IsNullOrEmpty(path) && File.Exists(path))
{
continue;
}
ArrayUtility.RemoveAt(ref dependenciesGUIDs, i);
foreach (var referenceInfo in assetReferencesInfo)
{
if (referenceInfo.assetInfo.GUID != guid)
{
continue;
}
ArrayUtility.Remove(ref assetReferencesInfo, referenceInfo);
break;
}
}
if (!needToRebuildReferences)
{
return;
}
}
foreach (var referenceInfo in assetReferencesInfo)
{
foreach (var info in referenceInfo.assetInfo.referencedAtInfoList)
{
if (info.assetInfo != this)
{
continue;
}
ArrayUtility.Remove(ref referenceInfo.assetInfo.referencedAtInfoList, info);
break;
}
}
lastHash = currentHash;
needToRebuildReferences = true;
Size = fileInfo.Length;
assetReferencesInfo = new AssetReferenceInfo[0];
dependenciesGUIDs = new string[0];
var dependencies = new List <string>();
if (SettingsKind == AssetSettingsKind.NotSettings)
{
var getRegularDependencies = true;
/* pre-regular dependencies additions */
if (Type == CSReflectionTools.assemblyDefinitionAssetType)
{
if (Kind == AssetKind.Regular)
{
//TODO: check if bug 1020737 is fixed and this can be removed
dependencies.AddRange(GetAssetsReferencedFromAssemblyDefinition(Path));
getRegularDependencies = false;
}
}
#if UNITY_2019_2_OR_NEWER
if (Type == CSReflectionTools.assemblyDefinitionReferenceAssetType)
{
if (Kind == AssetKind.Regular)
{
dependencies.AddRange(GetAssetsReferencedFromAssemblyDefinitionReference(Path));
getRegularDependencies = false;
}
}
#endif
#if UNITY_2018_2_OR_NEWER
// checking by name since addressables are in optional external package
if (Type != null && Type.Name == "AddressableAssetGroup")
{
var references = AddressablesReferenceFinder.Extract(Path);
if (references != null && references.Count > 0)
{
dependencies.AddRange(references);
}
}
#endif
/* regular dependencies additions */
if (getRegularDependencies)
{
dependencies.AddRange(AssetDatabase.GetDependencies(Path, false));
}
/* post-regular dependencies additions */
if (Type == CSReflectionTools.spriteAtlasType)
{
CSArrayTools.TryAddIfNotExists(ref dependencies, GetGetAssetsInFoldersReferencedFromSpriteAtlas(Path));
}
}
else
{
dependencies.AddRange(GetAssetsReferencedInPlayerSettingsAsset(Path, SettingsKind));
}
// kept for debugging purposes
/*if (Path.Contains("1.unity"))
* {
* Debug.Log("1.unity non-recursive dependencies:");
* foreach (var reference in references)
* {
* Debug.Log(reference);
* }
* }*/
if (Type == CSReflectionTools.shaderType)
{
// below is an another workaround for dependencies not include #include-ed files, like *.cginc
ScanFileForIncludes(dependencies, Path);
}
if (Type == CSReflectionTools.textAssetType && Path.EndsWith(".cginc"))
{
// below is an another workaround for dependencies not include #include-ed files, like *.cginc
ScanFileForIncludes(dependencies, Path);
}
var guids = new string[dependencies.Count];
for (var i = 0; i < dependencies.Count; i++)
{
guids[i] = AssetDatabase.AssetPathToGUID(dependencies[i]);
}
dependenciesGUIDs = guids;
}
protected override void ConstructBody(StringBuilder text)
{
text.Append("<b>Shader:</b> ");
text.Append(CSPathTools.NicifyAssetPath(Path, true));
}
private static void ScanFileForIncludes(List <string> referencePaths, string filePath)
{
var fileLines = File.ReadAllLines(filePath);
foreach (var line in fileLines)
{
var includeIndex = line.IndexOf("include", StringComparison.Ordinal);
if (includeIndex == -1)
{
continue;
}
var noSharp = line.IndexOf('#', 0, includeIndex) == -1;
if (noSharp)
{
continue;
}
var indexOfFirstQuote = line.IndexOf('"', includeIndex);
if (indexOfFirstQuote == -1)
{
continue;
}
var indexOfLastQuote = line.IndexOf('"', indexOfFirstQuote + 1);
if (indexOfLastQuote == -1)
{
continue;
}
var path = line.Substring(indexOfFirstQuote + 1, indexOfLastQuote - indexOfFirstQuote - 1);
path = CSPathTools.EnforceSlashes(path);
string assetPath;
if (path.StartsWith("Assets/"))
{
assetPath = path;
}
else if (path.IndexOf('/') != -1)
{
var folder = System.IO.Path.GetDirectoryName(filePath);
if (folder == null)
{
continue;
}
var combinedPath = System.IO.Path.Combine(folder, path);
var fullPath = CSPathTools.EnforceSlashes(System.IO.Path.GetFullPath(combinedPath));
var assetsIndex = fullPath.IndexOf("Assets/", StringComparison.Ordinal);
if (assetsIndex == -1)
{
continue;
}
assetPath = fullPath.Substring(assetsIndex, fullPath.Length - assetsIndex);
}
else
{
var folder = System.IO.Path.GetDirectoryName(filePath);
if (folder == null)
{
continue;
}
assetPath = CSPathTools.EnforceSlashes(System.IO.Path.Combine(folder, path));
}
if (!File.Exists(assetPath))
{
continue;
}
if (referencePaths.IndexOf(assetPath) != -1)
{
continue;
}
{
referencePaths.Add(assetPath);
}
}
}
private void DrawMoreButton(AssetIssueRecord record)
{
if (!UIHelpers.RecordButton(record, "Shows menu with additional actions for this record.", CSIcons.More))
{
return;
}
var menu = new GenericMenu();
if (!string.IsNullOrEmpty(record.Path))
{
menu.AddItem(new GUIContent("Ignore/Full Path"), false, () =>
{
if (!CSFilterTools.IsValueMatchesAnyFilter(record.Path, ProjectSettings.Issues.pathIgnoresFilters))
{
var newFilter = FilterItem.Create(record.Path, FilterKind.Path);
ArrayUtility.Add(ref ProjectSettings.Issues.pathIgnoresFilters, newFilter);
ApplyNewIgnoreFilter(newFilter);
MaintainerWindow.ShowNotification("Ignore added: " + record.Path);
CleanerFiltersWindow.Refresh();
}
else
{
MaintainerWindow.ShowNotification("Already added to the ignores!");
}
});
var dir = Directory.GetParent(record.Path);
if (!CSPathTools.IsAssetsRootPath(dir.FullName))
{
menu.AddItem(new GUIContent("Ignore/Parent Folder"), false, () =>
{
var dirPath = CSPathTools.EnforceSlashes(dir.ToString());
if (!CSFilterTools.IsValueMatchesAnyFilter(dirPath, ProjectSettings.Issues.pathIgnoresFilters))
{
var newFilter = FilterItem.Create(dirPath, FilterKind.Directory);
ArrayUtility.Add(ref ProjectSettings.Issues.pathIgnoresFilters, newFilter);
ApplyNewIgnoreFilter(newFilter);
MaintainerWindow.ShowNotification("Ignore added: " + dirPath);
CleanerFiltersWindow.Refresh();
}
else
{
MaintainerWindow.ShowNotification("Already added to the ignores!");
}
});
}
}
var objectIssue = record as GameObjectIssueRecord;
if (objectIssue != null)
{
if (!string.IsNullOrEmpty(objectIssue.componentName))
{
menu.AddItem(new GUIContent("Ignore/\"" + objectIssue.componentName + "\" Component"), false, () =>
{
if (!CSFilterTools.IsValueMatchesAnyFilter(objectIssue.componentName, ProjectSettings.Issues.componentIgnoresFilters))
{
var newFilter = FilterItem.Create(objectIssue.componentName, FilterKind.Type);
ArrayUtility.Add(ref ProjectSettings.Issues.componentIgnoresFilters, newFilter);
ApplyNewIgnoreFilter(newFilter);
MaintainerWindow.ShowNotification("Ignore added: " + objectIssue.componentName);
CleanerFiltersWindow.Refresh();
}
else
{
MaintainerWindow.ShowNotification("Already added to the ignores!");
}
});
}
}
menu.ShowAsContext();
}
private void DrawMoreButton(AssetRecord assetRecord)
{
if (UIHelpers.RecordButton(assetRecord, "Shows menu with additional actions for this record.", CSIcons.More))
{
var menu = new GenericMenu();
if (!string.IsNullOrEmpty(assetRecord.path))
{
menu.AddItem(new GUIContent("Ignore/Full Path"), false, () =>
{
if (!CSFilterTools.IsValueMatchesAnyFilter(assetRecord.assetDatabasePath, MaintainerSettings.Cleaner.pathIgnoresFilters))
{
var newFilter = FilterItem.Create(assetRecord.assetDatabasePath, FilterKind.Path);
ArrayUtility.Add(ref MaintainerSettings.Cleaner.pathIgnoresFilters, newFilter);
MaintainerWindow.ShowNotification("Ignore added: " + assetRecord.assetDatabasePath);
CleanerFiltersWindow.Refresh();
if (MaintainerSettings.Cleaner.rescanAfterContextIgnore)
{
StartSearch();
}
}
else
{
MaintainerWindow.ShowNotification("Already added to the ignores!");
}
});
var dir = Directory.GetParent(assetRecord.assetDatabasePath);
if (!CSPathTools.IsAssetsRootPath(dir.FullName))
{
menu.AddItem(new GUIContent("Ignore/Parent Folder"), false, () =>
{
var dirPath = CSPathTools.EnforceSlashes(dir.ToString());
if (!CSFilterTools.IsValueMatchesAnyFilter(dirPath, MaintainerSettings.Cleaner.pathIgnoresFilters))
{
var newFilter = FilterItem.Create(dirPath, FilterKind.Directory);
ArrayUtility.Add(ref MaintainerSettings.Cleaner.pathIgnoresFilters, newFilter);
MaintainerWindow.ShowNotification("Ignore added: " + dirPath);
CleanerFiltersWindow.Refresh();
if (MaintainerSettings.Cleaner.rescanAfterContextIgnore)
{
StartSearch();
}
}
else
{
MaintainerWindow.ShowNotification("Already added to the ignores!");
}
});
}
var extension = Path.GetExtension(assetRecord.path);
if (!string.IsNullOrEmpty(extension))
{
menu.AddItem(new GUIContent("Ignore/\"" + extension + "\" Extension"), false, () =>
{
if (!CSFilterTools.IsValueMatchesAnyFilterOfKind(extension, MaintainerSettings.Cleaner.pathIgnoresFilters, FilterKind.Extension))
{
var newFilter = FilterItem.Create(extension, FilterKind.Extension, true);
ArrayUtility.Add(ref MaintainerSettings.Cleaner.pathIgnoresFilters, newFilter);
MaintainerWindow.ShowNotification("Ignore added: " + extension);
CleanerFiltersWindow.Refresh();
if (MaintainerSettings.Cleaner.rescanAfterContextIgnore)
{
StartSearch();
}
}
else
{
MaintainerWindow.ShowNotification("Already added to the ignores!");
}
});
}
}
menu.ShowAsContext();
}
}
protected override bool CheckNewItem(ref string newItem)
{
newItem = CSPathTools.EnforceSlashes(newItem);
return(true);
}
public static ReferencesTreeElement BuildTreeBranch(AssetInfo referencedAsset, int depth, int id, List <ReferencesTreeElement> results)
{
// excludes assets without references if necessary and excludes assets which were ignored
if (AssetIsFilteredOut(referencedAsset, depth))
{
return(null);
}
var assetPath = referencedAsset.Path;
var assetType = referencedAsset.Type;
string assetTypeName;
if (referencedAsset.SettingsKind == AssetSettingsKind.NotSettings)
{
assetTypeName = assetType != null && !string.IsNullOrEmpty(assetType.Name) ? assetType.Name : "Unknown type";
}
else
{
assetTypeName = "Settings Asset";
}
var element = new ReferencesTreeElement
{
id = id + results.Count,
name = CSPathTools.NicifyAssetPath(referencedAsset.Path, referencedAsset.Kind),
assetPath = assetPath,
assetTypeName = assetTypeName,
assetSize = referencedAsset.Size,
assetSizeFormatted = CSEditorTools.FormatBytes(referencedAsset.Size),
assetIsTexture = assetType != null && (assetType.BaseType == CSReflectionTools.textureType),
assetSettingsKind = referencedAsset.SettingsKind,
isReferenced = referencedAsset.referencedAtInfoList != null && referencedAsset.referencedAtInfoList.Length > 0,
depth = depth
};
results.Add(element);
var recursionId = CheckParentsForRecursion(element, results);
if (recursionId > -1)
{
element.name += " [RECURSION]";
element.recursionId = recursionId;
return(element);
}
if (referencedAsset.referencedAtInfoList.Length > 0)
{
foreach (var referencedAtInfo in referencedAsset.referencedAtInfoList)
{
//if (CSFilterTools.IsValueMatchesAnyFilter(referencedAtInfo.assetInfo.Path, MaintainerSettings.References.pathIgnoresFilters)) continue;
if (referencedAtInfo.assetInfo.Kind == AssetKind.FromPackage)
{
continue;
}
var newDepth = depth + 1;
if (newDepth > 1)
{
continue;
}
var childElement = BuildTreeBranch(referencedAtInfo.assetInfo, newDepth, id, results);
if (childElement == null)
{
continue;
}
var referencedAtType = referencedAtInfo.assetInfo.Type;
if (referencedAtType == CSReflectionTools.gameObjectType ||
referencedAtType == CSReflectionTools.sceneAssetType ||
referencedAtType == CSReflectionTools.monoScriptType ||
referencedAtType == CSReflectionTools.monoBehaviourType ||
referencedAtType != null && referencedAtType.BaseType == CSReflectionTools.scriptableObjectType)
{
if (referencedAtInfo.entries != null)
{
childElement.referencingEntries = referencedAtInfo.entries;
}
else
{
var collectedData = ReferencesFinder.ConjunctionInfoList.FirstOrDefault(d => d.asset == referencedAtInfo.assetInfo);
if (collectedData == null)
{
collectedData = new AssetConjunctions();
ReferencesFinder.ConjunctionInfoList.Add(collectedData);
collectedData.asset = referencedAtInfo.assetInfo;
}
var tc = collectedData.conjunctions.FirstOrDefault(c => c.referencedAsset == referencedAsset);
if (tc == null)
{
tc = new TreeConjunction
{
referencedAsset = referencedAsset,
referencedAtInfo = referencedAtInfo
};
collectedData.conjunctions.Add(tc);
}
tc.treeElements.Add(childElement);
}
}
}
}
return(element);
}
private static bool UpdateMap(AssetsMap map)
{
// ----------------------------------------
// getting all valid assets within project
// ----------------------------------------
if (EditorUtility.DisplayCancelableProgressBar("Updating Assets Map, phase 1 of 4", "Getting all valid assets...", 0))
{
Debug.LogError(Maintainer.LogPrefix + "Assets Map update was canceled by user.");
return(false);
}
var allAssetPaths = AssetDatabase.GetAllAssetPaths();
var validNewAssets = new List <RawAssetInfo>(allAssetPaths.Length);
foreach (var assetPath in allAssetPaths)
{
/*if (assetPath.Contains(@"ScriptableObjectScriptWithMissingScript"))
* {
* Debug.Log(assetPath);
* }*/
var kind = CSEditorTools.GetAssetKind(assetPath);
if (kind == AssetKind.Unsupported)
{
continue;
}
if (!File.Exists(assetPath))
{
continue;
}
if (AssetDatabase.IsValidFolder(assetPath))
{
continue;
}
var guid = AssetDatabase.AssetPathToGUID(assetPath);
var rawInfo = new RawAssetInfo
{
path = CSPathTools.EnforceSlashes(assetPath),
guid = guid,
kind = kind,
};
validNewAssets.Add(rawInfo);
}
// -----------------------------
// checking existing map assets
// -----------------------------
if (EditorUtility.DisplayCancelableProgressBar("Updating Assets Map, phase 2 of 4", "Checking existing assets in map...", 0))
{
Debug.LogError(Maintainer.LogPrefix + "Assets Map update was canceled by user.");
return(false);
}
var count = map.assets.Count;
#if !UNITY_2020_1_OR_NEWER
var updateStep = Math.Max(count / ProjectSettings.UpdateProgressStep, 1);
#endif
for (var i = count - 1; i > -1; i--)
{
#if !UNITY_2020_1_OR_NEWER
if (i % updateStep == 0 && i != 0)
#endif
{
var index = count - i;
if (EditorUtility.DisplayCancelableProgressBar("Updating Assets Map, phase 2 of 4", "Checking existing assets in map..." + index + "/" + count, (float)index / count))
{
EditorUtility.ClearProgressBar();
Debug.LogError(Maintainer.LogPrefix + "Assets Map update was canceled by user.");
return(false);
}
}
var assetInMap = map.assets[i];
if (assetInMap.Exists())
{
validNewAssets.RemoveAll(a => a.guid == assetInMap.GUID);
assetInMap.UpdateIfNeeded();
}
else
{
assetInMap.Clean();
map.assets.RemoveAt(i);
}
}
// ------------------------
// dealing with new assets
// ------------------------
if (EditorUtility.DisplayCancelableProgressBar("Updating Assets Map, phase 3 of 4", "Looking for new assets...", 0))
{
Debug.LogError(Maintainer.LogPrefix + "Assets Map update was canceled by user.");
return(false);
}
count = validNewAssets.Count;
#if !UNITY_2020_1_OR_NEWER
updateStep = Math.Max(count / ProjectSettings.UpdateProgressStep, 1);
#endif
for (var i = 0; i < count; i++)
{
#if !UNITY_2020_1_OR_NEWER
if (i % updateStep == 0 && i != 0)
#endif
{
if (EditorUtility.DisplayCancelableProgressBar("Updating Assets Map, phase 3 of 4",
"Looking for new assets..." + (i + 1) + "/" + count, (float)i / count))
{
Debug.LogError(Maintainer.LogPrefix + "Assets Map update was canceled by user.");
return(false);
}
}
var rawAssetInfo = validNewAssets[i];
var rawAssetInfoPath = rawAssetInfo.path;
var type = AssetDatabase.GetMainAssetTypeAtPath(rawAssetInfoPath);
if (type == null)
{
var loadedAsset = AssetDatabase.LoadMainAssetAtPath(rawAssetInfoPath);
if (loadedAsset == null)
{
if (rawAssetInfo.kind != AssetKind.FromPackage)
{
if (!CSAssetTools.IsAssetScriptableObjectWithMissingScript(rawAssetInfoPath))
{
Debug.LogWarning(Maintainer.LogPrefix + "Can't retrieve type of the asset:\n" +
rawAssetInfoPath);
continue;
}
}
else
{
continue;
}
}
else
{
type = loadedAsset.GetType();
}
}
var settingsKind = rawAssetInfo.kind == AssetKind.Settings ? GetSettingsKind(rawAssetInfoPath) : AssetSettingsKind.NotSettings;
var asset = AssetInfo.Create(rawAssetInfo, type, settingsKind);
map.assets.Add(asset);
}
if (EditorUtility.DisplayCancelableProgressBar("Updating Assets Map, phase 4 of 4", "Generating links...", 0))
{
Debug.LogError(Maintainer.LogPrefix + "Assets Map update was canceled by user.");
return(false);
}
count = map.assets.Count;
#if !UNITY_2020_1_OR_NEWER
updateStep = Math.Max(count / ProjectSettings.UpdateProgressStep, 1);
#endif
for (var i = 0; i < count; i++)
{
#if !UNITY_2020_1_OR_NEWER
if (i % updateStep == 0 && i != 0)
#endif
{
if (EditorUtility.DisplayCancelableProgressBar("Updating Assets Map, phase 4 of 4", "Generating links..." + (i + 1) + "/" + count, (float)i / count))
{
Debug.LogError(Maintainer.LogPrefix + "Assets Map update was canceled by user.");
return(false);
}
}
var asset = map.assets[i];
if (!asset.needToRebuildReferences)
{
continue;
}
var dependencies = asset.dependenciesGUIDs;
var referenceInfos = new List <AssetReferenceInfo>(asset.assetReferencesInfo);
foreach (var mapAsset in map.assets)
{
var referencedAtInfos = new List <ReferencedAtAssetInfo>(mapAsset.referencedAtInfoList);
foreach (var dependency in dependencies)
{
if (mapAsset.GUID != dependency)
{
continue;
}
if (mapAsset.Type == asset.Type && asset.Type == CSReflectionTools.fontType)
{
continue;
}
var referencedAtInfo = new ReferencedAtAssetInfo()
{
assetInfo = asset
};
referencedAtInfos.Add(referencedAtInfo);
var referenceInfo = new AssetReferenceInfo()
{
assetInfo = mapAsset
};
referenceInfos.Add(referenceInfo);
}
mapAsset.referencedAtInfoList = referencedAtInfos.ToArray();
}
asset.assetReferencesInfo = referenceInfos.ToArray();
asset.needToRebuildReferences = false;
}
/*Debug.Log("Total assets in map: " + map.assets.Count);
* foreach (var mapAsset in map.assets)
* {
* //if (!(mapAsset.path.Contains("frag_ab") || mapAsset.path.Contains("frag_ac"))) continue;
* if (!mapAsset.Path.Contains("NewAssembly")) continue;
*
* Debug.Log("==================================================\n" + mapAsset.Path + "\n" + mapAsset.Path);
* Debug.Log("[REFERENCED BY]");
* foreach (var reference in mapAsset.referencedAtInfoList)
* {
* Debug.Log(reference.assetInfo.Path);
* }
*
* Debug.Log("[REFERENCES]");
* foreach (var reference in mapAsset.assetReferencesInfo)
* {
* Debug.Log(reference.assetInfo.Path);
* }
* }*/
return(true);
}
public void UpdateIfNeeded()
{
if (string.IsNullOrEmpty(Path))
{
Debug.LogWarning(Maintainer.LogPrefix + "Can't update Asset since path is not set!");
return;
}
/*if (Path.Contains("qwerty.unity"))
* {
* Debug.Log(Path);
* }*/
fileInfo.Refresh();
if (!fileInfo.Exists)
{
Debug.LogWarning(Maintainer.LogPrefix + "Can't update asset since file at path is not found:\n" + fileInfo.FullName + "\nAsset Path: " + Path);
return;
}
ulong currentHash = 0;
if (metaFileInfo == null)
{
metaFileInfo = new FileInfo(fileInfo.FullName + ".meta");
}
metaFileInfo.Refresh();
if (metaFileInfo.Exists)
{
currentHash += (ulong)metaFileInfo.LastWriteTimeUtc.Ticks;
currentHash += (ulong)metaFileInfo.Length;
}
currentHash += (ulong)fileInfo.LastWriteTimeUtc.Ticks;
currentHash += (ulong)fileInfo.Length;
if (lastHash == currentHash)
{
for (var i = dependenciesGUIDs.Length - 1; i > -1; i--)
{
var guid = dependenciesGUIDs[i];
var path = AssetDatabase.GUIDToAssetPath(guid);
path = CSPathTools.EnforceSlashes(path);
if (!string.IsNullOrEmpty(path) && File.Exists(path))
{
continue;
}
ArrayUtility.RemoveAt(ref dependenciesGUIDs, i);
foreach (var referenceInfo in assetReferencesInfo)
{
if (referenceInfo.assetInfo.GUID != guid)
{
continue;
}
ArrayUtility.Remove(ref assetReferencesInfo, referenceInfo);
break;
}
}
if (!needToRebuildReferences)
{
return;
}
}
foreach (var referenceInfo in assetReferencesInfo)
{
foreach (var info in referenceInfo.assetInfo.referencedAtInfoList)
{
if (info.assetInfo != this)
{
continue;
}
ArrayUtility.Remove(ref referenceInfo.assetInfo.referencedAtInfoList, info);
break;
}
}
lastHash = currentHash;
needToRebuildReferences = true;
Size = fileInfo.Length;
assetReferencesInfo = new AssetReferenceInfo[0];
dependenciesGUIDs = AssetDependenciesSearcher.FindDependencies(SettingsKind, Type, Kind, Path);
}
