You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1250 lines
30 KiB
C#
1250 lines
30 KiB
C#
using System;
|
|
using System.IO;
|
|
using System.Xml;
|
|
using System.Xml.Serialization;
|
|
using UnityEngine;
|
|
|
|
|
|
namespace BuildReportTool
|
|
{
|
|
|
|
// class for holding options
|
|
// this is the class that is serialized when saving the options
|
|
[System.Serializable, XmlRoot("BuildReportToolOptions")]
|
|
public class SavedOptions
|
|
{
|
|
public string EditorLogOverridePath;
|
|
|
|
public string BuildReportFolderName = BuildReportTool.Options.BUILD_REPORTS_DEFAULT_FOLDER_NAME;
|
|
|
|
/// <summary>
|
|
/// Where build reports are saved to: <br/>
|
|
/// 0: in user's My Documents <br/>
|
|
/// 1: or outside the project folder.
|
|
/// </summary>
|
|
public int SaveType;
|
|
|
|
// ----------------------------------------------------------
|
|
|
|
public bool CollectBuildInfo = true;
|
|
public bool CalculateAssetDependencies = true;
|
|
public bool CalculateAssetDependenciesOnUnusedToo = false;
|
|
|
|
public bool GetProjectSettings = true;
|
|
|
|
public bool IncludeUsedAssetsInReportCreation = true;
|
|
public bool IncludeUnusedAssetsInReportCreation = true;
|
|
public bool IncludeUnusedPrefabsInReportCreation = true;
|
|
public bool IncludeBuildSizeInReportCreation = true;
|
|
|
|
public bool IncludeSvnInUnused = true;
|
|
public bool IncludeGitInUnused = true;
|
|
|
|
public bool GetSizeBeforeBuildForUsedAssets = true;
|
|
public bool GetImportedSizesForUnusedAssets = true;
|
|
|
|
// ----------------------------------------------------------
|
|
|
|
/// <summary>
|
|
/// 0: Use file filters from global config. <br/>
|
|
/// 1: Use file filters embedded in the saved build report file.
|
|
/// </summary>
|
|
public int FilterToUseInt;
|
|
|
|
public int AssetListPaginationLength = 300;
|
|
public int UnusedAssetsEntriesPerBatch = 1000;
|
|
|
|
public bool DoubleClickOnAssetWillPing = false;
|
|
|
|
/// <summary>
|
|
/// Method of displaying labels that explain how one asset uses another. <br/>
|
|
/// 0: verbose (use words only) <br/>
|
|
/// 1: standard (use arrows when possible, use words for extra info) <br/>
|
|
/// 2: minimal (use arrows only, don't show extra info even if available)
|
|
/// </summary>
|
|
public int AssetUsageLabelType;
|
|
|
|
public bool ShowAssetPrimaryUsersInTooltipIfAvailable = true;
|
|
|
|
public bool ShowTooltipThumbnail = true;
|
|
|
|
/// <summary>
|
|
/// 0: Thumbnail should appear when mouse is hovering over asset icon only. <br/>
|
|
/// 1: Thumbnail should appear when mouse is hovering over asset label too, not just on the icon.
|
|
/// </summary>
|
|
public int ShowThumbnailOnHoverType;
|
|
|
|
public int TooltipThumbnailWidth = 256;
|
|
public int TooltipThumbnailHeight = 256;
|
|
|
|
public int TooltipThumbnailZoomedInWidth = 512;
|
|
public int TooltipThumbnailZoomedInHeight = 512;
|
|
|
|
public int NumberOfTopLargestUsedAssetsToShow = 10;
|
|
public int NumberOfTopLargestUnusedAssetsToShow = 10;
|
|
|
|
// ----------------------------------------------------------
|
|
|
|
public bool AllowDeletingOfUsedAssets;
|
|
public bool ShowImportedSizeForUsedAssets = false;
|
|
|
|
public bool AutoShowWindowAfterNormalBuild = true;
|
|
public bool AutoResortAssetsWhenUnityEditorRegainsFocus = false;
|
|
|
|
public bool UseThreadedReportGeneration = true;
|
|
public bool UseThreadedFileLoading = false;
|
|
|
|
// ----------------------------------------------------------
|
|
|
|
public void OnBeforeSave()
|
|
{
|
|
// get rid of invalid characters for folder name
|
|
// but still allow slash/backward slash so user could make relative paths
|
|
|
|
BuildReportFolderName = BuildReportFolderName.Replace(":", string.Empty);
|
|
BuildReportFolderName = BuildReportFolderName.Replace("*", string.Empty);
|
|
BuildReportFolderName = BuildReportFolderName.Replace("?", string.Empty);
|
|
BuildReportFolderName = BuildReportFolderName.Replace("\"", string.Empty);
|
|
BuildReportFolderName = BuildReportFolderName.Replace("<", string.Empty);
|
|
BuildReportFolderName = BuildReportFolderName.Replace(">", string.Empty);
|
|
BuildReportFolderName = BuildReportFolderName.Replace("|", string.Empty);
|
|
}
|
|
|
|
public static void Save(string savePath, SavedOptions optionsToSave)
|
|
{
|
|
optionsToSave.OnBeforeSave();
|
|
|
|
XmlSerializer x = new XmlSerializer( typeof(SavedOptions) );
|
|
TextWriter writer = new StreamWriter(savePath);
|
|
x.Serialize(writer, optionsToSave);
|
|
writer.Close();
|
|
|
|
//Debug.LogFormat("Build Report Tool: Saved options to: {0}", savePath);
|
|
}
|
|
|
|
public static SavedOptions Load(string path)
|
|
{
|
|
SavedOptions result = null;
|
|
|
|
XmlSerializer x = new XmlSerializer( typeof(SavedOptions) );
|
|
|
|
try
|
|
{
|
|
using (FileStream fs = new FileStream(path, FileMode.Open))
|
|
{
|
|
if (fs.Length == 0)
|
|
{
|
|
// nothing inside
|
|
return null;
|
|
}
|
|
XmlReader reader = new XmlTextReader(fs);
|
|
result = (SavedOptions) x.Deserialize(reader);
|
|
fs.Close();
|
|
}
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
Debug.LogFormat("Build Report Tool: Error found upon loading options XML file in {0}\nWill create a new options file instead.\n\nError: {1}", path, e);
|
|
return new SavedOptions();
|
|
}
|
|
|
|
//Debug.LogFormat("Build Report Tool: Loaded options from: {0}", path);
|
|
return result;
|
|
}
|
|
}
|
|
|
|
public static class Options
|
|
{
|
|
// =======================================================
|
|
// constants
|
|
public const string BUILD_REPORT_PACKAGE_MOVED_MSG = "BuildReport package seems to have been moved. Finding...";
|
|
|
|
public const string BUILD_REPORT_PACKAGE_MISSING_MSG = "Unable to find BuildReport package folder! Cannot find suitable GUI Skin.\nTry editing the source code and change the value\nof `BUILD_REPORT_TOOL_DEFAULT_PATH` to what path the Build Report Tool is in.\nMake sure the folder is named \"BuildReport\".";
|
|
|
|
public const string BUILD_REPORT_TOOL_DEFAULT_PATH = "Assets/BuildReport";
|
|
public const string BUILD_REPORT_TOOL_DEFAULT_FOLDER_NAME = "BuildReport";
|
|
|
|
public const string BUILD_REPORTS_DEFAULT_FOLDER_NAME = "UnityBuildReports";
|
|
|
|
|
|
public const int SAVE_TYPE_PERSONAL = 0;
|
|
public const int SAVE_TYPE_PROJECT = 1;
|
|
|
|
|
|
public const int ASSET_USAGE_LABEL_TYPE_VERBOSE = 0;
|
|
public const int ASSET_USAGE_LABEL_TYPE_STANDARD = 1;
|
|
public const int ASSET_USAGE_LABEL_TYPE_MINIMAL = 2;
|
|
|
|
// =======================================================
|
|
//
|
|
static BuildReportTool.SavedOptions _savedOptions;
|
|
static string _foundPathForSavedOptions;
|
|
const string SAVED_OPTIONS_FILENAME = "BuildReportToolOptions.xml";
|
|
|
|
static string DefaultOptionsPath
|
|
{
|
|
get
|
|
{
|
|
return string.Format("{0}/BuildReport/{1}", Application.dataPath, SAVED_OPTIONS_FILENAME);
|
|
}
|
|
}
|
|
|
|
static bool IsBuildReportInRegularPaths
|
|
{
|
|
get
|
|
{
|
|
return Directory.Exists(string.Format("{0}/BuildReport", Application.dataPath)) ||
|
|
Directory.Exists(string.Format("{0}/Plugins/BuildReport", Application.dataPath));
|
|
}
|
|
}
|
|
|
|
public static string FoundPathForSavedOptions
|
|
{
|
|
get { return _foundPathForSavedOptions; }
|
|
}
|
|
|
|
static void InitializeOptionsIfNeeded()
|
|
{
|
|
if (_savedOptions == null)
|
|
{
|
|
_foundPathForSavedOptions = string.Empty;
|
|
}
|
|
|
|
if (string.IsNullOrEmpty(_foundPathForSavedOptions))
|
|
{
|
|
// look for the file in this order:
|
|
// 1. inside the BuildReport folder
|
|
// 2. at the very topmost Assets folder
|
|
// 3. outside the Assets folder
|
|
// 4. in the ProjectSettings folder
|
|
// 5. in the User's My Documents folder
|
|
|
|
|
|
// ---------------------------------------------------
|
|
// look in /Assets/BuildReport/
|
|
var optionsInBuildReportFolder = DefaultOptionsPath;
|
|
if (File.Exists(optionsInBuildReportFolder))
|
|
{
|
|
_savedOptions = BuildReportTool.SavedOptions.Load(optionsInBuildReportFolder);
|
|
_foundPathForSavedOptions = optionsInBuildReportFolder;
|
|
return;
|
|
}
|
|
|
|
// ---------------------------------------------------
|
|
// look in /Assets/Plugins/BuildReport/
|
|
var optionsInPluginsBuildReport = string.Format("{0}/Plugins/BuildReport/{1}", Application.dataPath, SAVED_OPTIONS_FILENAME);
|
|
if (File.Exists(optionsInPluginsBuildReport))
|
|
{
|
|
_savedOptions = BuildReportTool.SavedOptions.Load(optionsInPluginsBuildReport);
|
|
_foundPathForSavedOptions = optionsInPluginsBuildReport;
|
|
return;
|
|
}
|
|
|
|
// ---------------------------------------------------
|
|
// search for "BuildReport" folder and look in there
|
|
if (!IsBuildReportInRegularPaths)
|
|
{
|
|
string customBuildReportFolder = BuildReportTool.Util.FindAssetFolder(Application.dataPath, BUILD_REPORT_TOOL_DEFAULT_FOLDER_NAME);
|
|
if (!string.IsNullOrEmpty(customBuildReportFolder))
|
|
{
|
|
var optionsInCustomBuildReportFolder = string.Format("{0}/{1}", customBuildReportFolder, SAVED_OPTIONS_FILENAME);
|
|
if (File.Exists(optionsInCustomBuildReportFolder))
|
|
{
|
|
_savedOptions = BuildReportTool.SavedOptions.Load(optionsInCustomBuildReportFolder);
|
|
_foundPathForSavedOptions = optionsInCustomBuildReportFolder;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------
|
|
// look in /Assets/
|
|
var optionsInTopmostAssets = string.Format("{0}/{1}", Application.dataPath, SAVED_OPTIONS_FILENAME);
|
|
if (File.Exists(optionsInTopmostAssets))
|
|
{
|
|
_savedOptions = BuildReportTool.SavedOptions.Load(optionsInTopmostAssets);
|
|
_foundPathForSavedOptions = optionsInTopmostAssets;
|
|
return;
|
|
}
|
|
|
|
// ---------------------------------------------------
|
|
// look in Unity project folder (where Assets, Library, and ProjectSettings folder are)
|
|
var outsideAssets = BuildReportTool.Util.GetProjectPath(Application.dataPath);
|
|
var optionsOutsideAssets = string.Format("{0}{1}", outsideAssets, SAVED_OPTIONS_FILENAME);
|
|
if (File.Exists(optionsOutsideAssets))
|
|
{
|
|
_savedOptions = BuildReportTool.SavedOptions.Load(optionsOutsideAssets);
|
|
_foundPathForSavedOptions = optionsOutsideAssets;
|
|
return;
|
|
}
|
|
|
|
// ---------------------------------------------------
|
|
// look inside ProjectSettings folder
|
|
var optionsInProjectSettings = string.Format("{0}ProjectSettings/{1}", outsideAssets, SAVED_OPTIONS_FILENAME);
|
|
//Debug.LogFormat("Looking in {0}", optionsInProjectSettings);
|
|
if (File.Exists(optionsInProjectSettings))
|
|
{
|
|
_savedOptions = BuildReportTool.SavedOptions.Load(optionsInProjectSettings);
|
|
_foundPathForSavedOptions = optionsInProjectSettings;
|
|
return;
|
|
}
|
|
|
|
// ---------------------------------------------------
|
|
// look in /My Documents/UnityBuildReports/
|
|
var optionsInMyDocs = string.Format("{0}/{1}/{2}", BuildReportTool.Util.GetUserHomeFolder(), BUILD_REPORTS_DEFAULT_FOLDER_NAME, SAVED_OPTIONS_FILENAME);
|
|
//Debug.LogFormat("Looking in {0}", optionsInMyDocs);
|
|
if (File.Exists(optionsInMyDocs))
|
|
{
|
|
_savedOptions = BuildReportTool.SavedOptions.Load(optionsInMyDocs);
|
|
_foundPathForSavedOptions = optionsInMyDocs;
|
|
return;
|
|
}
|
|
|
|
// ---------------------------------------------------
|
|
}
|
|
|
|
// if the options file failed to load
|
|
// one last try
|
|
//
|
|
if (_savedOptions == null)
|
|
{
|
|
if (!string.IsNullOrEmpty(_foundPathForSavedOptions) && File.Exists(_foundPathForSavedOptions))
|
|
{
|
|
// there's a valid options file already
|
|
// just load that one
|
|
_savedOptions = BuildReportTool.SavedOptions.Load(_foundPathForSavedOptions);
|
|
}
|
|
}
|
|
|
|
// could not load the file, or there isn't one yet (at least, not in any recognized valid paths).
|
|
// so create a new one at the default path
|
|
if (_savedOptions == null)
|
|
{
|
|
_savedOptions = new BuildReportTool.SavedOptions();
|
|
_foundPathForSavedOptions = DefaultOptionsPath;
|
|
|
|
var defaultFolder = Path.GetDirectoryName(_foundPathForSavedOptions);
|
|
if (!string.IsNullOrEmpty(defaultFolder) && !Directory.Exists(defaultFolder))
|
|
{
|
|
Directory.CreateDirectory(defaultFolder);
|
|
}
|
|
|
|
SavedOptions.Save(_foundPathForSavedOptions, _savedOptions);
|
|
Debug.LogFormat("Build Report Tool: Created a new options file at: {0}", _foundPathForSavedOptions);
|
|
}
|
|
}
|
|
|
|
public static void RefreshOptions()
|
|
{
|
|
_foundPathForSavedOptions = string.Empty;
|
|
_savedOptions = null;
|
|
InitializeOptionsIfNeeded();
|
|
}
|
|
|
|
static void SaveOptions()
|
|
{
|
|
if (string.IsNullOrEmpty(_foundPathForSavedOptions))
|
|
{
|
|
return;
|
|
}
|
|
if (_savedOptions == null || !File.Exists(_foundPathForSavedOptions))
|
|
{
|
|
_foundPathForSavedOptions = string.Empty;
|
|
return;
|
|
}
|
|
|
|
SavedOptions.Save(_foundPathForSavedOptions, _savedOptions);
|
|
}
|
|
|
|
// =======================================================
|
|
// user options
|
|
|
|
public static string EditorLogOverridePath
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.EditorLogOverridePath;
|
|
}
|
|
set
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
if (_savedOptions.EditorLogOverridePath != value)
|
|
{
|
|
_savedOptions.EditorLogOverridePath = value;
|
|
SaveOptions();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static bool IncludeSvnInUnused
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.IncludeSvnInUnused;
|
|
}
|
|
set
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
if (_savedOptions.IncludeSvnInUnused != value)
|
|
{
|
|
_savedOptions.IncludeSvnInUnused = value;
|
|
SaveOptions();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static bool IncludeGitInUnused
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.IncludeGitInUnused;
|
|
}
|
|
set
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
if (_savedOptions.IncludeGitInUnused != value)
|
|
{
|
|
_savedOptions.IncludeGitInUnused = value;
|
|
SaveOptions();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static FileFilterDisplay GetOptionFileFilterDisplay()
|
|
{
|
|
return FileFilterDisplay.DropDown;
|
|
}
|
|
|
|
public static bool AllowDeletingOfUsedAssets
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.AllowDeletingOfUsedAssets;
|
|
}
|
|
set
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
if (_savedOptions.AllowDeletingOfUsedAssets != value)
|
|
{
|
|
_savedOptions.AllowDeletingOfUsedAssets = value;
|
|
SaveOptions();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static bool CollectBuildInfo
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.CollectBuildInfo;
|
|
}
|
|
set
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
if (_savedOptions.CollectBuildInfo != value)
|
|
{
|
|
_savedOptions.CollectBuildInfo = value;
|
|
SaveOptions();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static bool CalculateAssetDependencies
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.CalculateAssetDependencies;
|
|
}
|
|
set
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
if (_savedOptions.CalculateAssetDependencies != value)
|
|
{
|
|
_savedOptions.CalculateAssetDependencies = value;
|
|
SaveOptions();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static bool CalculateAssetDependenciesOnUnusedToo
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.CalculateAssetDependenciesOnUnusedToo;
|
|
}
|
|
set
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
if (_savedOptions.CalculateAssetDependenciesOnUnusedToo != value)
|
|
{
|
|
_savedOptions.CalculateAssetDependenciesOnUnusedToo = value;
|
|
SaveOptions();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static string BuildReportFolderName
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.BuildReportFolderName;
|
|
}
|
|
set
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
if (_savedOptions.BuildReportFolderName != value)
|
|
{
|
|
_savedOptions.BuildReportFolderName = value;
|
|
SaveOptions();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Full path to folder where Build Reports are saved.
|
|
/// Note: Makes use of Application.dataPath so it has to be called from the main thread.
|
|
/// </summary>
|
|
public static string BuildReportSavePath
|
|
{
|
|
get
|
|
{
|
|
if (BuildReportTool.Options.SaveType == BuildReportTool.Options.SAVE_TYPE_PERSONAL)
|
|
{
|
|
return BuildReportTool.Util.GetUserHomeFolder() + "/" + BuildReportFolderName;
|
|
}
|
|
else
|
|
{
|
|
// assume BuildReportTool.Options.SaveType == BuildReportTool.Options.SAVE_TYPE_PROJECT
|
|
|
|
// makes use of Application.dataPath so it has to be called from the main thread
|
|
return BuildReportTool.ReportGenerator.GetSavePathToProjectFolder() + "/" + BuildReportFolderName;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
public static int SaveType
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.SaveType;
|
|
}
|
|
set
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
if (_savedOptions.SaveType != value)
|
|
{
|
|
_savedOptions.SaveType = value;
|
|
SaveOptions();
|
|
}
|
|
}
|
|
}
|
|
|
|
public enum FileFilterDisplay
|
|
{
|
|
DropDown = 0,
|
|
Buttons = 1
|
|
}
|
|
|
|
|
|
|
|
public enum FilterToUseType
|
|
{
|
|
UseConfiguredFile,
|
|
UseEmbedded
|
|
}
|
|
|
|
public static FilterToUseType GetOptionFilterToUse()
|
|
{
|
|
switch (FilterToUseInt)
|
|
{
|
|
case 0:
|
|
return FilterToUseType.UseConfiguredFile;
|
|
case 1:
|
|
return FilterToUseType.UseEmbedded;
|
|
}
|
|
return FilterToUseType.UseConfiguredFile;
|
|
}
|
|
|
|
public static bool ShouldUseConfiguredFileFilters()
|
|
{
|
|
//Debug.Log("GetOptionFilterToUse() " + GetOptionFilterToUse());
|
|
return GetOptionFilterToUse() == FilterToUseType.UseConfiguredFile;
|
|
}
|
|
|
|
public static bool ShouldUseEmbeddedFileFilters()
|
|
{
|
|
return GetOptionFilterToUse() == FilterToUseType.UseEmbedded;
|
|
}
|
|
|
|
public static int FilterToUseInt
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.FilterToUseInt;
|
|
}
|
|
set
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
if (_savedOptions.FilterToUseInt != value)
|
|
{
|
|
_savedOptions.FilterToUseInt = value;
|
|
SaveOptions();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
public static int AssetListPaginationLength
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.AssetListPaginationLength;
|
|
}
|
|
set
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
if (_savedOptions.AssetListPaginationLength != value)
|
|
{
|
|
_savedOptions.AssetListPaginationLength = value;
|
|
SaveOptions();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
public static int AssetUsageLabelType
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.AssetUsageLabelType;
|
|
}
|
|
set
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
if (_savedOptions.AssetUsageLabelType != value)
|
|
{
|
|
_savedOptions.AssetUsageLabelType = value;
|
|
SaveOptions();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static bool IsAssetUsageLabelTypeOnVerbose
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.AssetUsageLabelType == ASSET_USAGE_LABEL_TYPE_VERBOSE;
|
|
}
|
|
}
|
|
|
|
public static bool IsAssetUsageLabelTypeOnStandard
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.AssetUsageLabelType == ASSET_USAGE_LABEL_TYPE_STANDARD;
|
|
}
|
|
}
|
|
|
|
public static bool IsAssetUsageLabelTypeOnMinimal
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.AssetUsageLabelType == ASSET_USAGE_LABEL_TYPE_MINIMAL;
|
|
}
|
|
}
|
|
|
|
|
|
public static bool DoubleClickOnAssetWillPing
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.DoubleClickOnAssetWillPing;
|
|
}
|
|
set
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
if (_savedOptions.DoubleClickOnAssetWillPing != value)
|
|
{
|
|
_savedOptions.DoubleClickOnAssetWillPing = value;
|
|
SaveOptions();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public static bool ShowAssetPrimaryUsersInTooltipIfAvailable
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.ShowAssetPrimaryUsersInTooltipIfAvailable;
|
|
}
|
|
set
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
if (_savedOptions.ShowAssetPrimaryUsersInTooltipIfAvailable != value)
|
|
{
|
|
_savedOptions.ShowAssetPrimaryUsersInTooltipIfAvailable = value;
|
|
SaveOptions();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static bool ShowTooltipThumbnail
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.ShowTooltipThumbnail;
|
|
}
|
|
set
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
if (_savedOptions.ShowTooltipThumbnail != value)
|
|
{
|
|
_savedOptions.ShowTooltipThumbnail = value;
|
|
SaveOptions();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static int ShowThumbnailOnHoverType
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.ShowThumbnailOnHoverType;
|
|
}
|
|
set
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
if (_savedOptions.ShowThumbnailOnHoverType != value)
|
|
{
|
|
_savedOptions.ShowThumbnailOnHoverType = value;
|
|
SaveOptions();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// If thumbnail should appear when mouse is hovering over asset label too, not just on the icon.
|
|
/// </summary>
|
|
public static bool ShowThumbnailOnHoverLabelToo
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.ShowThumbnailOnHoverType == 1;
|
|
}
|
|
}
|
|
|
|
public static int TooltipThumbnailWidth
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.TooltipThumbnailWidth;
|
|
}
|
|
set
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
if (_savedOptions.TooltipThumbnailWidth != value)
|
|
{
|
|
_savedOptions.TooltipThumbnailWidth = value;
|
|
SaveOptions();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static int TooltipThumbnailHeight
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.TooltipThumbnailHeight;
|
|
}
|
|
set
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
if (_savedOptions.TooltipThumbnailHeight != value)
|
|
{
|
|
_savedOptions.TooltipThumbnailHeight = value;
|
|
SaveOptions();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public static int TooltipThumbnailZoomedInWidth
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.TooltipThumbnailZoomedInWidth;
|
|
}
|
|
set
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
if (_savedOptions.TooltipThumbnailZoomedInWidth != value)
|
|
{
|
|
_savedOptions.TooltipThumbnailZoomedInWidth = value;
|
|
SaveOptions();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static int TooltipThumbnailZoomedInHeight
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.TooltipThumbnailZoomedInHeight;
|
|
}
|
|
set
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
if (_savedOptions.TooltipThumbnailZoomedInHeight != value)
|
|
{
|
|
_savedOptions.TooltipThumbnailZoomedInHeight = value;
|
|
SaveOptions();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public static int UnusedAssetsEntriesPerBatch
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.UnusedAssetsEntriesPerBatch;
|
|
}
|
|
set
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
if (_savedOptions.UnusedAssetsEntriesPerBatch != value)
|
|
{
|
|
_savedOptions.UnusedAssetsEntriesPerBatch = value;
|
|
SaveOptions();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static int NumberOfTopLargestUsedAssetsToShow
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.NumberOfTopLargestUsedAssetsToShow;
|
|
}
|
|
set
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
if (_savedOptions.NumberOfTopLargestUsedAssetsToShow != value)
|
|
{
|
|
_savedOptions.NumberOfTopLargestUsedAssetsToShow = value;
|
|
SaveOptions();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static int NumberOfTopLargestUnusedAssetsToShow
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.NumberOfTopLargestUnusedAssetsToShow;
|
|
}
|
|
set
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
if (_savedOptions.NumberOfTopLargestUnusedAssetsToShow != value)
|
|
{
|
|
_savedOptions.NumberOfTopLargestUnusedAssetsToShow = value;
|
|
SaveOptions();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Build Report Calculation
|
|
// Full report
|
|
// No prefabs in unused assets calculation
|
|
// No unused assets calculation, but still has used assets list (won't collect prefabs in scene)
|
|
// No used assets and unused assets calculation (overview only)
|
|
|
|
public static bool IncludeUsedAssetsInReportCreation
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.IncludeUsedAssetsInReportCreation;
|
|
}
|
|
set
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
if (_savedOptions.IncludeUsedAssetsInReportCreation != value)
|
|
{
|
|
_savedOptions.IncludeUsedAssetsInReportCreation = value;
|
|
SaveOptions();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static bool IncludeUnusedAssetsInReportCreation
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.IncludeUnusedAssetsInReportCreation;
|
|
}
|
|
set
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
if (_savedOptions.IncludeUnusedAssetsInReportCreation != value)
|
|
{
|
|
_savedOptions.IncludeUnusedAssetsInReportCreation = value;
|
|
SaveOptions();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static bool IncludeUnusedPrefabsInReportCreation
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.IncludeUnusedPrefabsInReportCreation;
|
|
}
|
|
set
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
if (_savedOptions.IncludeUnusedPrefabsInReportCreation != value)
|
|
{
|
|
_savedOptions.IncludeUnusedPrefabsInReportCreation = value;
|
|
SaveOptions();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public static bool IncludeBuildSizeInReportCreation
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.IncludeBuildSizeInReportCreation;
|
|
}
|
|
set
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
if (_savedOptions.IncludeBuildSizeInReportCreation != value)
|
|
{
|
|
_savedOptions.IncludeBuildSizeInReportCreation = value;
|
|
SaveOptions();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static bool ShowImportedSizeForUsedAssets
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.ShowImportedSizeForUsedAssets;
|
|
}
|
|
set
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
if (_savedOptions.ShowImportedSizeForUsedAssets != value)
|
|
{
|
|
_savedOptions.ShowImportedSizeForUsedAssets = value;
|
|
SaveOptions();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static bool GetSizeBeforeBuildForUsedAssets
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.GetSizeBeforeBuildForUsedAssets;
|
|
}
|
|
set
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
if (_savedOptions.GetSizeBeforeBuildForUsedAssets != value)
|
|
{
|
|
_savedOptions.GetSizeBeforeBuildForUsedAssets = value;
|
|
SaveOptions();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static bool GetImportedSizesForUnusedAssets
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.GetImportedSizesForUnusedAssets;
|
|
}
|
|
set
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
if (_savedOptions.GetImportedSizesForUnusedAssets != value)
|
|
{
|
|
_savedOptions.GetImportedSizesForUnusedAssets = value;
|
|
SaveOptions();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
public static bool GetProjectSettings
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.GetProjectSettings;
|
|
}
|
|
set
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
if (_savedOptions.GetProjectSettings != value)
|
|
{
|
|
_savedOptions.GetProjectSettings = value;
|
|
SaveOptions();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public static bool IsCalculationLevelAtFull(bool includeUsedAssets, bool includeUnusedAssets, bool includeUnusedPrefabs)
|
|
{
|
|
return includeUsedAssets && includeUnusedAssets && includeUnusedPrefabs;
|
|
}
|
|
|
|
public static bool IsCalculationLevelAtNoUnusedPrefabs(bool includeUsedAssets, bool includeUnusedAssets, bool includeUnusedPrefabs)
|
|
{
|
|
return includeUsedAssets && includeUnusedAssets && !includeUnusedPrefabs;
|
|
}
|
|
|
|
public static bool IsCalculationLevelAtNoUnusedAssets(bool includeUsedAssets, bool includeUnusedAssets, bool includeUnusedPrefabs)
|
|
{
|
|
// unused prefabs are not checked. if unused assets are not calculated, it is understood that unused prefabs are not included
|
|
return includeUsedAssets && !includeUnusedAssets;
|
|
}
|
|
|
|
public static bool IsCalculationLevelAtOverviewOnly(bool includeUsedAssets, bool includeUnusedAssets, bool includeUnusedPrefabs)
|
|
{
|
|
// if used assets not included, it is understood that unused assets are not included too.
|
|
// if used assets are not included, there is no way to determing if an asset is unused.
|
|
return !includeUsedAssets;
|
|
}
|
|
|
|
|
|
|
|
|
|
public static bool IsCurrentCalculationLevelAtFull
|
|
{
|
|
get
|
|
{
|
|
return IsCalculationLevelAtFull(IncludeUsedAssetsInReportCreation, IncludeUnusedAssetsInReportCreation, IncludeUnusedPrefabsInReportCreation);
|
|
}
|
|
}
|
|
public static bool IsCurrentCalculationLevelAtNoUnusedPrefabs
|
|
{
|
|
get
|
|
{
|
|
return IsCalculationLevelAtNoUnusedPrefabs(IncludeUsedAssetsInReportCreation, IncludeUnusedAssetsInReportCreation, IncludeUnusedPrefabsInReportCreation);
|
|
}
|
|
}
|
|
public static bool IsCurrentCalculationLevelAtNoUnusedAssets
|
|
{
|
|
get
|
|
{
|
|
return IsCalculationLevelAtNoUnusedAssets(IncludeUsedAssetsInReportCreation, IncludeUnusedAssetsInReportCreation, IncludeUnusedPrefabsInReportCreation);
|
|
}
|
|
}
|
|
public static bool IsCurrentCalculationLevelAtOverviewOnly
|
|
{
|
|
get
|
|
{
|
|
return IsCalculationLevelAtOverviewOnly(IncludeUsedAssetsInReportCreation, IncludeUnusedAssetsInReportCreation, IncludeUnusedPrefabsInReportCreation);
|
|
}
|
|
}
|
|
|
|
|
|
public static void SetCalculationLevelToFull()
|
|
{
|
|
IncludeUsedAssetsInReportCreation = true;
|
|
IncludeUnusedAssetsInReportCreation = true;
|
|
IncludeUnusedPrefabsInReportCreation = true;
|
|
}
|
|
public static void SetCalculationLevelToNoUnusedPrefabs()
|
|
{
|
|
IncludeUsedAssetsInReportCreation = true;
|
|
IncludeUnusedAssetsInReportCreation = true;
|
|
IncludeUnusedPrefabsInReportCreation = false;
|
|
}
|
|
public static void SetCalculationLevelToNoUnusedAssets()
|
|
{
|
|
IncludeUsedAssetsInReportCreation = true;
|
|
IncludeUnusedAssetsInReportCreation = false;
|
|
IncludeUnusedPrefabsInReportCreation = false;
|
|
}
|
|
public static void SetCalculationLevelToOverviewOnly()
|
|
{
|
|
IncludeUsedAssetsInReportCreation = false;
|
|
IncludeUnusedAssetsInReportCreation = false;
|
|
IncludeUnusedPrefabsInReportCreation = false;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
public static bool AutoShowWindowAfterNormalBuild
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.AutoShowWindowAfterNormalBuild;
|
|
}
|
|
set
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
if (_savedOptions.AutoShowWindowAfterNormalBuild != value)
|
|
{
|
|
_savedOptions.AutoShowWindowAfterNormalBuild = value;
|
|
SaveOptions();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static bool AutoResortAssetsWhenUnityEditorRegainsFocus
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.AutoResortAssetsWhenUnityEditorRegainsFocus;
|
|
}
|
|
set
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
if (_savedOptions.AutoResortAssetsWhenUnityEditorRegainsFocus != value)
|
|
{
|
|
_savedOptions.AutoResortAssetsWhenUnityEditorRegainsFocus = value;
|
|
SaveOptions();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public static bool UseThreadedReportGeneration
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.UseThreadedReportGeneration;
|
|
}
|
|
set
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
if (_savedOptions.UseThreadedReportGeneration != value)
|
|
{
|
|
_savedOptions.UseThreadedReportGeneration = value;
|
|
SaveOptions();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static bool UseThreadedFileLoading
|
|
{
|
|
get
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
return _savedOptions.UseThreadedFileLoading;
|
|
}
|
|
set
|
|
{
|
|
InitializeOptionsIfNeeded();
|
|
if (_savedOptions.UseThreadedFileLoading != value)
|
|
{
|
|
_savedOptions.UseThreadedFileLoading = value;
|
|
SaveOptions();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
public static bool ShouldShowWindowAfterBuild
|
|
{
|
|
get
|
|
{
|
|
return (!IsInBatchMode && AutoShowWindowAfterNormalBuild);
|
|
}
|
|
}
|
|
|
|
public static bool IsInBatchMode
|
|
{
|
|
get
|
|
{
|
|
return UnityEditorInternal.InternalEditorUtility.inBatchMode;
|
|
|
|
|
|
#if OTHER_BATCH_MODE_DETECTION_CODE
|
|
// different ways to find out actually.
|
|
// included here in case a new version of Unity
|
|
// removes our current way of figuring out batchmode.
|
|
|
|
// check the isHumanControllingUs bool
|
|
return UnityEditorInternal.InternalEditorUtility.isHumanControllingUs;
|
|
|
|
// check the command line args for "-batchmode"
|
|
string[] arguments = Environment.GetCommandLineArgs();
|
|
for (int n = 0, len = arguments.Length; n < len; ++n)
|
|
{
|
|
if (arguments[n] == "-batchmode")
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|