コード例 #1
0
ファイル: ProjectCleaner.cs プロジェクト: s1gurd/W-Hub
 private static void CheckScenesForExistence(ICollection <CleanerRecord> results, List <string> ignoredScenes)
 {
     for (var i = ignoredScenes.Count - 1; i >= 0; i--)
     {
         var scenePath = ignoredScenes[i];
         if (!File.Exists(scenePath))
         {
             results.Add(CleanerErrorRecord.Create("Scene " + Path.GetFileName(scenePath) + " from Ignores or Build Settings not found!"));
             ignoredScenes.RemoveAt(i);
         }
     }
 }
コード例 #2
0
ファイル: ProjectCleaner.cs プロジェクト: Pinkpanterus/DPND
        private static bool ScanProjectFiles(ICollection <CleanerRecord> results, bool showProgress = true)
        {
            currentPhase++;

            var ignoredScenes = new List <string>();

            if (ProjectSettings.Cleaner.ignoreScenesInBuild)
            {
                ignoredScenes.AddRange(CSSceneTools.GetScenesInBuild(!ProjectSettings.Cleaner.ignoreOnlyEnabledScenesInBuild));
            }

            foreach (var sceneFilter in ProjectSettings.Cleaner.sceneIgnoresFilters)
            {
                if (!sceneFilter.enabled)
                {
                    continue;
                }

                if (ignoredScenes.IndexOf(sceneFilter.value) == -1)
                {
                    ignoredScenes.Add(sceneFilter.value);
                }
            }

            CheckScenesForExistence(results, ignoredScenes);

            if (ignoredScenes.Count == 0)
            {
                if (!UserSettings.Cleaner.muteNoIgnoredScenesWarning)
                {
                    var dialogResult = EditorUtility.DisplayDialogComplex(
                        "No ignored scenes!",
                        "No scenes were added to the build settings or to the Filters > Scenes Ignores.\n" +
                        "All not ignored scenes are treated as unused if not referenced somewhere in other ignored assets.",
                        "Proceed anyway",
                        "Proceed and never show again", "Cancel");

                    if (dialogResult == 1)
                    {
                        UserSettings.Cleaner.muteNoIgnoredScenesWarning = true;
                        UserSettings.Save();
                    }
                    else if (dialogResult == 2)
                    {
                        return(false);
                    }
                }

                results.Add(CleanerWarningRecord.Create("No scenes added to the build settings or Filters > Scenes Ignores tab.\n" +
                                                        "Search may include all assets used in your game scenes!"));
            }

            var map = AssetsMap.GetUpdated();

            if (map == null)
            {
                results.Add(CleanerErrorRecord.Create("Can't get assets map!"));
                return(false);
            }

            EditorUtility.DisplayCancelableProgressBar(string.Format(ProgressCaption, currentPhase, phasesCount, 0, 0), "Analyzing Assets Map for references...", 0);

#if UNITY_2019_3_OR_NEWER
            BuildReportAnalyzer.Init();
#endif

            var allAssetsInProject = map.assets;
            var count = allAssetsInProject.Count;

#if !UNITY_2020_1_OR_NEWER
            var updateStep = Math.Max(count / ProjectSettings.UpdateProgressStep, 1);
#endif
            var referencedAssets = new HashSet <AssetInfo>();

            for (var i = 0; i < count; i++)
            {
                if (showProgress
#if !UNITY_2020_1_OR_NEWER
                    && i % updateStep == 0
#endif
                    && i != 0 && EditorUtility.DisplayCancelableProgressBar(
                        string.Format(ProgressCaption, currentPhase, phasesCount, i + 1, count), "Analyzing Assets Map for references...",
                        (float)(i + 1) / count))
                {
                    return(true);
                }

                var asset = allAssetsInProject[i];

                /*if (asset.Path.EndsWith("1.pdf"))
                 * {
                 *      Debug.Log(asset.Type);
                 *      if (asset.Type == CSReflectionTools.defaultAssetType)
                 *      {
                 *              var importer = AssetImporter.GetAtPath(asset.Path);
                 *              Debug.Log(importer);
                 *      }
                 * }*/

                if (asset.Kind != AssetKind.Regular)
                {
                    continue;
                }

                if (AssetInIgnores(asset, ignoredScenes))
                {
                    referencedAssets.Add(asset);
                    var references = asset.GetReferencesRecursive();
                    foreach (var reference in references)
                    {
                        referencedAssets.Add(reference);
                    }
                }

#if UNITY_2019_3_OR_NEWER
                if (BuildReportAnalyzer.IsFileInBuildReport(asset.GUID))
                {
                    referencedAssets.Add(asset);
                    var references = asset.GetReferencesRecursive();
                    foreach (var reference in references)
                    {
                        if (!referencedAssets.Contains(reference))
                        {
                            referencedAssets.Add(reference);
                        }
                    }
                }
#endif

                if (AssetInIgnoresSecondPass(asset, referencedAssets))
                {
                    referencedAssets.Add(asset);
                    var references = asset.GetReferencesRecursive();
                    foreach (var reference in references)
                    {
                        if (!referencedAssets.Contains(reference))
                        {
                            referencedAssets.Add(reference);
                        }
                    }
                }
            }

            var unreferencedAssets = new List <AssetInfo>(count);
            for (var i = 0; i < count; i++)
            {
                if (showProgress
#if !UNITY_2020_1_OR_NEWER
                    && i % updateStep == 0
#endif
                    && i != 0 && EditorUtility.DisplayCancelableProgressBar(
                        string.Format(ProgressCaption, currentPhase, phasesCount, i + 1, count), "Filtering out unreferenced assets...",
                        (float)(i + 1) / count))
                {
                    return(true);
                }

                var asset = allAssetsInProject[i];

                if (asset.Kind != AssetKind.Regular)
                {
                    continue;
                }

                if (CSFilterTools.HasEnabledFilters(ProjectSettings.Cleaner.pathIncludesFilters))
                {
                    if (!CSFilterTools.IsValueMatchesAnyFilter(asset.Path, ProjectSettings.Cleaner.pathIncludesFilters))
                    {
                        continue;
                    }
                }

                if (!referencedAssets.Contains(asset))
                {
                    if (unreferencedAssets.IndexOf(asset) == -1)
                    {
                        unreferencedAssets.Add(asset);
                    }
                }
            }

            count = unreferencedAssets.Count;

#if !UNITY_2020_1_OR_NEWER
            updateStep = Math.Max(count / ProjectSettings.UpdateProgressStep, 1);
#endif

            for (var i = count - 1; i > -1; i--)
            {
                if (showProgress
#if !UNITY_2020_1_OR_NEWER
                    && i % updateStep == 0
#endif
                    && i != 0)
                {
                    var index = count - i;
                    if (EditorUtility.DisplayCancelableProgressBar(
                            string.Format(ProgressCaption, currentPhase, phasesCount, index, count), "Populating results...",
                            (float)index / count))
                    {
                        return(true);
                    }
                }

                var unreferencedAsset = unreferencedAssets[i];
                results.Add(AssetRecord.Create(RecordType.UnreferencedAsset, unreferencedAsset));
            }

            return(false);
        }
コード例 #3
0
ファイル: ProjectCleaner.cs プロジェクト: s1gurd/W-Hub
        private static bool ScanProjectFiles(ICollection <CleanerRecord> results, bool showProgress = true)
        {
            currentPhase++;

            var ignoredScenes = new List <string>();

            if (MaintainerSettings.Cleaner.ignoreScenesInBuild)
            {
                ignoredScenes.AddRange(CSSceneTools.GetScenesInBuild(!MaintainerSettings.Cleaner.ignoreOnlyEnabledScenesInBuild));
            }

            foreach (var scene in MaintainerSettings.Cleaner.sceneIgnoresFilters)
            {
                if (ignoredScenes.IndexOf(scene.value) == -1)
                {
                    ignoredScenes.Add(scene.value);
                }
            }

            CheckScenesForExistence(results, ignoredScenes);

            if (ignoredScenes.Count == 0)
            {
                results.Add(CleanerErrorRecord.Create("Please tell me what scenes you wish to keep.\n" +
                                                      "Add them to the build settings and / or configure manually\n" +
                                                      "at the Manage Filters > Scenes Ignores tab."));
                return(false);
            }

            var map = AssetsMap.GetUpdated();

            if (map == null)
            {
                results.Add(CleanerErrorRecord.Create("Can't get assets map!"));
                return(false);
            }

            EditorUtility.DisplayCancelableProgressBar(string.Format(ProgressCaption, currentPhase, phasesCount, 0, 0), "Analyzing Assets Map for references...", 0);

            var allAssetsInProject = map.assets;
            var count            = allAssetsInProject.Count;
            var updateStep       = Math.Max(count / MaintainerSettings.UpdateProgressStep, 1);
            var referencedAssets = new HashSet <AssetInfo>();

            for (var i = 0; i < count; i++)
            {
                if (showProgress && i % updateStep == 0 && i != 0 && EditorUtility.DisplayCancelableProgressBar(
                        string.Format(ProgressCaption, currentPhase, phasesCount, i + 1, count), "Analyzing Assets Map for references...",
                        (float)(i + 1) / count))
                {
                    return(true);
                }

                var asset = allAssetsInProject[i];

                /*if (asset.Path.EndsWith("1.pdf"))
                 * {
                 *      Debug.Log(asset.Type);
                 *      if (asset.Type == CSReflectionTools.defaultAssetType)
                 *      {
                 *              var importer = AssetImporter.GetAtPath(asset.Path);
                 *              Debug.Log(importer);
                 *      }
                 * }*/

                if (asset.Kind != AssetKind.Regular)
                {
                    continue;
                }

                if (AssetInIgnores(asset, ignoredScenes))
                {
                    referencedAssets.Add(asset);
                    var references = asset.GetReferencesRecursive();
                    foreach (var reference in references)
                    {
                        referencedAssets.Add(reference);
                    }
                }

                if (AssetInIgnoresSecondPass(asset, referencedAssets))
                {
                    referencedAssets.Add(asset);
                    var references = asset.GetReferencesRecursive();
                    foreach (var reference in references)
                    {
                        if (!referencedAssets.Contains(reference))
                        {
                            referencedAssets.Add(reference);
                        }
                    }
                }
            }

            var unreferencedAssets = new List <AssetInfo>(count);

            for (var i = 0; i < count; i++)
            {
                if (showProgress && i % updateStep == 0 && i != 0 && EditorUtility.DisplayCancelableProgressBar(
                        string.Format(ProgressCaption, currentPhase, phasesCount, i + 1, count), "Filtering out unreferenced assets...",
                        (float)(i + 1) / count))
                {
                    return(true);
                }

                var asset = allAssetsInProject[i];
                if (asset.Kind != AssetKind.Regular)
                {
                    continue;
                }

                if (!referencedAssets.Contains(asset))
                {
                    if (unreferencedAssets.IndexOf(asset) == -1)
                    {
                        unreferencedAssets.Add(asset);
                    }
                }
            }

            count      = unreferencedAssets.Count;
            updateStep = Math.Max(count / MaintainerSettings.UpdateProgressStep, 1);

            for (var i = count - 1; i > -1; i--)
            {
                if (showProgress && i % updateStep == 0 && i != 0)
                {
                    var index = count - i;
                    if (EditorUtility.DisplayCancelableProgressBar(
                            string.Format(ProgressCaption, currentPhase, phasesCount, index, count), "Populating results...",
                            (float)index / count))
                    {
                        return(true);
                    }
                }

                var unreferencedAsset = unreferencedAssets[i];
                results.Add(AssetRecord.Create(RecordType.UnreferencedAsset, unreferencedAsset));
            }

            return(false);
        }
コード例 #4
0
ファイル: ProjectCleaner.cs プロジェクト: rfHu/poker
        private static bool ScanProjectFiles(ICollection <CleanerRecord> results, bool showProgress = true)
        {
            currentPhase++;

            List <string> ignoredScenes = new List <string>();

            if (MaintainerSettings.Cleaner.ignoreScenesInBuild)
            {
                ignoredScenes.AddRange(CSSceneTools.GetScenesInBuild(!MaintainerSettings.Cleaner.ignoreOnlyEnabledScenesInBuild));
            }

            CheckScenesForExistence(results, ignoredScenes, "Scenes in build");

            foreach (string scene in MaintainerSettings.Cleaner.sceneIgnores)
            {
                if (!ignoredScenes.Contains(scene))
                {
                    ignoredScenes.Add(scene);
                }
            }

            CheckScenesForExistence(results, ignoredScenes, "Scene Ignores");

            if (ignoredScenes.Count == 0)
            {
                results.Add(CleanerErrorRecord.Create("No ignored scenes, terminating unused assets search!"));
                return(false);
            }

            List <string> ignores = MaintainerSettings.Cleaner.pathIgnores.ToList();

            ignores.Add("Assets/Editor Default Resources");
            ignores.Add("/Resources/");
            ignores.Add("/StreamingAssets/");
            ignores.Add("/Gizmos/");
            ignores.Add("/Editor/");
            ignores.Add("/Plugins/");
            ignores.Add(".dll");
            ignores.Add(".rsp");
            ignores.AddRange(ignoredScenes);
            ignores.AddRange(CSEditorTools.FindAssetsFiltered("t:Script"));

            List <string> assets                 = new List <string>();
            List <string> usedAssets             = new List <string>();
            List <string> assetsWithDependencies = new List <string>();

            string[] allAssets = CSEditorTools.FindAssetsFiltered("t:Object t:GUISkin", null, ignores.ToArray());
            int      count     = allAssets.Length;

            for (int i = 0; i < count; i++)
            {
                if (showProgress && EditorUtility.DisplayCancelableProgressBar(string.Format(PROGRESS_CAPTION, currentPhase, phasesCount, i + 1, count), "Gathering all assets...", (float)i / count))
                {
                    return(true);
                }

                string asset = allAssets[i];

                if (File.Exists(asset))
                {
                    if (assets.IndexOf(asset) == -1)
                    {
                        assets.Add(asset);
                    }
                }
            }

            assetsWithDependencies.AddRange(ignoredScenes);

            List <string> foldersAddedToBuild = new List <string>();

            foldersAddedToBuild.AddRange(CSEditorTools.FindFoldersFiltered("Resources"));
            foldersAddedToBuild.AddRange(CSEditorTools.FindFoldersFiltered("StreamingAssets"));

            assetsWithDependencies.AddRange(CSEditorTools.FindAssetsInFolders("t:Object t:GUISkin", foldersAddedToBuild.ToArray()));

            count = assetsWithDependencies.Count;

            for (int i = 0; i < count; i++)
            {
                if (showProgress && EditorUtility.DisplayCancelableProgressBar(string.Format(PROGRESS_CAPTION, currentPhase, phasesCount, i + 1, count), "Looking for dependencies...", (float)i / count))
                {
                    return(true);
                }

                string[] dependencies = AssetDatabase.GetDependencies(new [] { assetsWithDependencies[i] });

                foreach (string dependency in dependencies)
                {
                    if (!File.Exists(dependency))
                    {
                        continue;
                    }

                    if (usedAssets.IndexOf(dependency) == -1)
                    {
                        usedAssets.Add(dependency);
                    }
                }
            }

            foreach (string usedAsset in usedAssets)
            {
                if (assets.IndexOf(usedAsset) != -1)
                {
                    assets.Remove(usedAsset);
                }
            }

            foreach (string asset in assets)
            {
                results.Add(AssetRecord.Create(RecordType.UnusedAsset, asset));
            }

            return(false);
        }