663 lines
24 KiB
C#
663 lines
24 KiB
C#
using System;
|
|
using System.Collections;
|
|
using UnityEngine;
|
|
using UnityEditor;
|
|
using UnityEditor.Presets;
|
|
using UnityEditor.Animations;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Collections.Generic;
|
|
using Object = UnityEngine.Object;
|
|
|
|
namespace DreadScripts.AssetOrganizer
|
|
{
|
|
public class AssetOrganizer : EditorWindow
|
|
{
|
|
#region Declarations
|
|
#region Constants
|
|
|
|
private const string PrefsKey = "AvatarAssetOrganizerSettings";
|
|
private static readonly OrganizeType[] organizeTypes =
|
|
{
|
|
new OrganizeType(0, "Animation", typeof(AnimationClip), typeof(BlendTree)),
|
|
new OrganizeType(1, "Controller", typeof(AnimatorController), typeof(AnimatorOverrideController)),
|
|
new OrganizeType(2, "Texture", typeof(Texture)),
|
|
new OrganizeType(3, "Material", typeof(Material)),
|
|
new OrganizeType(4, "Model", new string[] {".fbx",".obj", ".dae", ".3ds", ".dxf"}, typeof(Mesh)),
|
|
new OrganizeType(5, "Prefab", new string[] {".prefab"}, typeof(GameObject)),
|
|
new OrganizeType(6, "Audio", typeof(AudioClip)),
|
|
new OrganizeType(7, "Mask", typeof(AvatarMask)),
|
|
new OrganizeType(8, "Scene", typeof(SceneAsset)),
|
|
new OrganizeType(9, "Preset", typeof(Preset)),
|
|
new OrganizeType(10, "VRC", "VRC.SDK3.Avatars.ScriptableObjects.VRCExpressionParameters","VRC.SDK3.Avatars.ScriptableObjects.VRCExpressionsMenu"),
|
|
new OrganizeType(11, "Shader", typeof(Shader)),
|
|
new OrganizeType(12, "Script", new string[] {".dll"}, typeof(MonoScript)),
|
|
new OrganizeType(13, "Other", typeof(ScriptableObject))
|
|
};
|
|
private static readonly string[] mainTabs = {"Organizer", "Options"};
|
|
private static readonly string[] optionTabs = {"Folders", "Types"};
|
|
|
|
|
|
private enum OrganizeAction
|
|
{
|
|
Skip,
|
|
Move
|
|
//Removed till an intuitive way for user friendly GUID replacement option is implemented
|
|
//Copy
|
|
}
|
|
|
|
private enum SortOptions
|
|
{
|
|
AlphabeticalPath,
|
|
AlphabeticalAsset,
|
|
AssetType
|
|
}
|
|
#endregion
|
|
#region Automated Variables
|
|
private static int mainToolbarIndex;
|
|
private static int optionsToolbarIndex;
|
|
private static DependencyAsset[] assets;
|
|
private static List<string> createdFolders = new List<string>();
|
|
private Vector2 scrollview;
|
|
#endregion
|
|
#region Input
|
|
private static Object mainAsset;
|
|
private static string destinationPath;
|
|
|
|
[SerializeField] private List<CustomFolder> specialFolders;
|
|
[SerializeField] private OrganizeAction[] typeActions;
|
|
[SerializeField] private SortOptions sortByOption;
|
|
[SerializeField] private bool deleteEmptyFolders = true;
|
|
#endregion
|
|
#endregion
|
|
|
|
#region Methods
|
|
#region Main Methods
|
|
private void OnGUI()
|
|
{
|
|
scrollview = EditorGUILayout.BeginScrollView(scrollview);
|
|
mainToolbarIndex = GUILayout.Toolbar(mainToolbarIndex, mainTabs);
|
|
|
|
switch (mainToolbarIndex)
|
|
{
|
|
case 0:
|
|
DrawOrganizerTab();
|
|
break;
|
|
case 1:
|
|
DrawOptionsTab();
|
|
break;
|
|
}
|
|
|
|
DrawSeparator();
|
|
Credit();
|
|
EditorGUILayout.EndScrollView();
|
|
}
|
|
private void GetDependencyAssets()
|
|
{
|
|
destinationPath = AssetDatabase.GetAssetPath(mainAsset);
|
|
bool isFolder = AssetDatabase.IsValidFolder(destinationPath);
|
|
string[] assetsPath = isFolder ? GetAssetPathsInFolder(destinationPath).ToArray() : AssetDatabase.GetDependencies(destinationPath);
|
|
assets = assetsPath.Select(p => new DependencyAsset(p)).ToArray();
|
|
|
|
if (!isFolder) destinationPath = destinationPath.Replace('\\', '/').Substring(0, destinationPath.LastIndexOf('/'));
|
|
|
|
foreach (var a in assets)
|
|
{
|
|
string[] subFolders = a.path.Split('/');
|
|
|
|
bool setByFolder = false;
|
|
foreach (var f in specialFolders)
|
|
{
|
|
if (!f.active) continue;
|
|
if (subFolders.All(s => s != f.name)) continue;
|
|
|
|
a.action = f.action;
|
|
setByFolder = true;
|
|
break;
|
|
|
|
}
|
|
|
|
if (setByFolder) continue;
|
|
|
|
if (!TrySetAction(a))
|
|
a.associatedType = organizeTypes.Last();
|
|
}
|
|
|
|
switch (sortByOption)
|
|
{
|
|
case SortOptions.AlphabeticalPath:
|
|
assets = assets.OrderBy(a => a.path).ToArray();
|
|
break;
|
|
case SortOptions.AlphabeticalAsset:
|
|
assets = assets.OrderBy(a => a.asset.name).ToArray();
|
|
break;
|
|
case SortOptions.AssetType:
|
|
assets = assets.OrderBy(a => a.type.Name).ToArray();
|
|
break;
|
|
}
|
|
|
|
}
|
|
private void OrganizeAssets()
|
|
{
|
|
CheckFolders();
|
|
List<string> affectedFolders = new List<string>();
|
|
try
|
|
{
|
|
AssetDatabase.StartAssetEditing();
|
|
int count = assets.Length;
|
|
float progressPerAsset = 1f / count;
|
|
for (var i = 0; i < count; i++)
|
|
{
|
|
EditorUtility.DisplayProgressBar("Organizing", $"Organizing Assets ({i+1}/{count})", (i + 1) * progressPerAsset);
|
|
var a = assets[i];
|
|
string newPath = AssetDatabase.GenerateUniqueAssetPath($"{destinationPath}/{a.associatedType.name}/{Path.GetFileName(a.path)}");
|
|
switch (a.action)
|
|
{
|
|
default: case OrganizeAction.Skip: continue;
|
|
case OrganizeAction.Move:
|
|
AssetDatabase.MoveAsset(a.path, newPath);
|
|
affectedFolders.Add(Path.GetDirectoryName(a.path));
|
|
break;
|
|
/*case OrganizeAction.Copy:
|
|
AssetDatabase.CopyAsset(a.path, newPath);
|
|
break;*/
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
EditorUtility.ClearProgressBar();
|
|
AssetDatabase.StopAssetEditing();
|
|
}
|
|
|
|
try
|
|
{
|
|
AssetDatabase.StartAssetEditing();
|
|
|
|
foreach (var folderPath in createdFolders.Concat(affectedFolders).Distinct().Where(DirectoryIsEmpty))
|
|
AssetDatabase.DeleteAsset(folderPath);
|
|
}
|
|
finally { AssetDatabase.StopAssetEditing(); }
|
|
|
|
EditorGUIUtility.PingObject(AssetDatabase.LoadMainAssetAtPath(destinationPath));
|
|
|
|
assets = null;
|
|
destinationPath = null;
|
|
}
|
|
#endregion
|
|
#region GUI Methods
|
|
|
|
private void DrawOrganizerTab()
|
|
{
|
|
GUIStyle boxStyle = GUI.skin.GetStyle("box");
|
|
|
|
using (new GUILayout.HorizontalScope())
|
|
{
|
|
EditorGUI.BeginChangeCheck();
|
|
mainAsset = EditorGUILayout.ObjectField("Main Asset", mainAsset, typeof(Object), false);
|
|
if (EditorGUI.EndChangeCheck())
|
|
{
|
|
if (mainAsset)
|
|
{
|
|
destinationPath = AssetDatabase.GetAssetPath(mainAsset);
|
|
if (!AssetDatabase.IsValidFolder(destinationPath)) destinationPath = Path.GetDirectoryName(destinationPath).Replace('\\', '/');
|
|
}
|
|
assets = null;
|
|
}
|
|
|
|
using (new EditorGUI.DisabledScope(!mainAsset))
|
|
if (GUILayout.Button("Get Assets", GUILayout.Width(80)))
|
|
GetDependencyAssets();
|
|
}
|
|
|
|
destinationPath = AssetFolderPath(destinationPath, "Destination Folder");
|
|
|
|
|
|
if (assets != null)
|
|
{
|
|
DrawSeparator(4, 20);
|
|
|
|
var h = EditorGUIUtility.singleLineHeight;
|
|
var squareOptions = new GUILayoutOption[] { GUILayout.Width(h), GUILayout.Height(h) };
|
|
foreach (var a in assets)
|
|
{
|
|
using (new GUILayout.HorizontalScope(boxStyle))
|
|
{
|
|
GUILayout.Label(a.icon, squareOptions);
|
|
if (GUILayout.Button($"| {a.path}", GUI.skin.label))
|
|
EditorGUIUtility.PingObject(a.asset);
|
|
|
|
a.action = (OrganizeAction)EditorGUILayout.EnumPopup(a.action, GUILayout.Width(60));
|
|
}
|
|
|
|
}
|
|
|
|
if (GUILayout.Button("Organize Assets"))
|
|
OrganizeAssets();
|
|
|
|
}
|
|
}
|
|
|
|
private void DrawOptionsTab()
|
|
{
|
|
optionsToolbarIndex = GUILayout.Toolbar(optionsToolbarIndex, optionTabs);
|
|
switch (optionsToolbarIndex)
|
|
{
|
|
case 0:
|
|
DrawFolderOptions();
|
|
break;
|
|
case 1:
|
|
DrawTypeOptions();
|
|
break;
|
|
}
|
|
|
|
DrawSeparator();
|
|
using (new GUILayout.HorizontalScope("helpbox"))
|
|
{
|
|
deleteEmptyFolders = EditorGUILayout.Toggle(new GUIContent("Delete Empty Folders", "After moving assets, delete source folders if they're empty"), deleteEmptyFolders);
|
|
sortByOption = (SortOptions)EditorGUILayout.EnumPopup("Sort Search By", sortByOption);
|
|
}
|
|
}
|
|
|
|
private void DrawFolderOptions()
|
|
{
|
|
for (var i = 0; i < specialFolders.Count; i++)
|
|
{
|
|
var f = specialFolders[i];
|
|
using (new GUILayout.HorizontalScope("helpbox"))
|
|
{
|
|
using (new BGColoredScope(Color.green, Color.grey, f.active))
|
|
f.active = GUILayout.Toggle(f.active, f.active ? "Enabled" : "Disabled", GUI.skin.button, GUILayout.Width(100), GUILayout.Height(18));
|
|
using (new EditorGUI.DisabledScope(!f.active))
|
|
{
|
|
f.name = GUILayout.TextField(f.name);
|
|
f.action = (OrganizeAction) EditorGUILayout.EnumPopup(f.action, GUILayout.Width(60));
|
|
if (GUILayout.Button("X", GUILayout.Width(18), GUILayout.Height(18)))
|
|
specialFolders.RemoveAt(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (GUILayout.Button("Add"))
|
|
specialFolders.Add(new CustomFolder());
|
|
}
|
|
|
|
private void DrawTypeOptions()
|
|
{
|
|
using (new GUILayout.HorizontalScope())
|
|
{
|
|
void DrawTypeGUI(OrganizeType t)
|
|
{
|
|
var icon = GUIContent.none;
|
|
if (t.associatedTypes.Length > 0)
|
|
icon = new GUIContent(AssetPreview.GetMiniTypeThumbnail(t.associatedTypes[0]));
|
|
|
|
using (new GUILayout.HorizontalScope())
|
|
{
|
|
GUILayout.Label(icon, GUILayout.Height(18), GUILayout.Width(18));
|
|
GUILayout.Label($"| {t.name}");
|
|
if (TryGetTypeAction(t, out _))
|
|
typeActions[t.actionIndex] = (OrganizeAction)EditorGUILayout.EnumPopup(typeActions[t.actionIndex], GUILayout.Width(60));
|
|
}
|
|
}
|
|
|
|
using (new GUILayout.VerticalScope("helpbox"))
|
|
{
|
|
for (int i = 0; i < organizeTypes.Length; i+=2)
|
|
DrawTypeGUI(organizeTypes[i]);
|
|
}
|
|
using (new GUILayout.VerticalScope("helpbox"))
|
|
{
|
|
for (int i = 1; i < organizeTypes.Length; i += 2)
|
|
DrawTypeGUI(organizeTypes[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static string AssetFolderPath(string variable, string title)
|
|
{
|
|
using (new GUILayout.HorizontalScope())
|
|
{
|
|
EditorGUILayout.TextField(title, variable);
|
|
|
|
if (GUILayout.Button("...", GUILayout.Width(30)))
|
|
{
|
|
var dummyPath = EditorUtility.OpenFolderPanel(title, AssetDatabase.IsValidFolder(variable) ? variable : "Assets", string.Empty);
|
|
if (string.IsNullOrEmpty(dummyPath))
|
|
return variable;
|
|
string newPath = FileUtil.GetProjectRelativePath(dummyPath);
|
|
|
|
if (!newPath.StartsWith("Assets"))
|
|
{
|
|
Debug.LogWarning("New Path must be a folder within Assets!");
|
|
return variable;
|
|
}
|
|
|
|
variable = newPath;
|
|
}
|
|
}
|
|
|
|
return variable;
|
|
}
|
|
|
|
private static void DrawSeparator(int thickness = 2, int padding = 10)
|
|
{
|
|
Rect r = EditorGUILayout.GetControlRect(GUILayout.Height(thickness + padding));
|
|
r.height = thickness;
|
|
r.y += padding / 2f;
|
|
r.x -= 2;
|
|
r.width += 6;
|
|
ColorUtility.TryParseHtmlString(EditorGUIUtility.isProSkin ? "#595959" : "#858585", out Color lineColor);
|
|
EditorGUI.DrawRect(r, lineColor);
|
|
}
|
|
#endregion
|
|
|
|
#region Sub-Main Methods
|
|
|
|
[MenuItem("DreadTools/Asset Organizer", false, 36)]
|
|
private static void ShowWindow() => GetWindow<AssetOrganizer>(false, "Asset Organizer", true);
|
|
private bool TrySetAction(DependencyAsset a)
|
|
{
|
|
for (int i = 0; i < organizeTypes.Length; i++)
|
|
{
|
|
if (!organizeTypes[i].IsAppliedTo(a)) continue;
|
|
|
|
if (TryGetTypeAction(organizeTypes[i], out var action))
|
|
{
|
|
a.action = action;
|
|
a.associatedType = organizeTypes[i];
|
|
return true;
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private bool TryGetTypeAction(OrganizeType type, out OrganizeAction action)
|
|
{
|
|
bool hasDoubleTried = false;
|
|
TryAgain:
|
|
try
|
|
{
|
|
action = typeActions[type.actionIndex];
|
|
return true;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
if (hasDoubleTried) throw;
|
|
|
|
OrganizeAction[] newArray = new OrganizeAction[organizeTypes.Length];
|
|
for (int j = 0; j < newArray.Length; j++)
|
|
{
|
|
try { newArray[j] = typeActions[j]; }
|
|
catch { newArray[j] = OrganizeAction.Skip; }
|
|
}
|
|
|
|
Debug.LogWarning("Type Actions re-initialized due to a loading/serialization.");
|
|
typeActions = newArray;
|
|
hasDoubleTried = true;
|
|
goto TryAgain;
|
|
}
|
|
}
|
|
|
|
private static void CheckFolders()
|
|
{
|
|
if (!destinationPath.StartsWith("Assets/"))
|
|
destinationPath = "Assets/" + destinationPath;
|
|
ReadyPath(destinationPath);
|
|
|
|
createdFolders.Clear();
|
|
|
|
void CheckFolder(string name)
|
|
{
|
|
string path = $"{destinationPath}/{name}";
|
|
if (ReadyPath(path)) createdFolders.Add(path);
|
|
}
|
|
|
|
try
|
|
{
|
|
AssetDatabase.StartAssetEditing();
|
|
for (int i = 0; i < organizeTypes.Length; i++)
|
|
CheckFolder(organizeTypes[i].name);
|
|
}
|
|
finally { AssetDatabase.StopAssetEditing(); }
|
|
}
|
|
public static void DeleteIfEmptyFolder(string folderPath)
|
|
{
|
|
if (!AssetDatabase.IsValidFolder(folderPath))
|
|
folderPath = Path.GetDirectoryName(folderPath);
|
|
while (DirectoryIsEmpty(folderPath) && folderPath != "Assets")
|
|
{
|
|
var parentDirectory = Path.GetDirectoryName(folderPath);
|
|
FileUtil.DeleteFileOrDirectory(folderPath);
|
|
FileUtil.DeleteFileOrDirectory(folderPath + ".meta");
|
|
folderPath = parentDirectory;
|
|
}
|
|
}
|
|
public static bool DirectoryIsEmpty(string path) => !Directory.EnumerateFileSystemEntries(path).Any();
|
|
#endregion
|
|
#region Automated Methods
|
|
private void OnEnable()
|
|
{
|
|
string data = EditorPrefs.GetString(PrefsKey, JsonUtility.ToJson(this, false));
|
|
JsonUtility.FromJsonOverwrite(data, this);
|
|
if (!EditorPrefs.HasKey(PrefsKey))
|
|
{
|
|
//Default Folder based actions. Based on usual VRC assets.
|
|
specialFolders = new List<CustomFolder>
|
|
{
|
|
new CustomFolder("VRCSDK"),
|
|
new CustomFolder("_PoiyomiShaders"),
|
|
new CustomFolder("VRLabs"),
|
|
new CustomFolder("PumkinsAvatarTools"),
|
|
new CustomFolder("DreadScripts"),
|
|
new CustomFolder("Packages"),
|
|
new CustomFolder("Plugins"),
|
|
new CustomFolder("Editor")
|
|
};
|
|
|
|
//Default Type based Actions
|
|
typeActions = new OrganizeAction[]
|
|
{
|
|
OrganizeAction.Move,
|
|
OrganizeAction.Move,
|
|
OrganizeAction.Move,
|
|
OrganizeAction.Move,
|
|
OrganizeAction.Move,
|
|
OrganizeAction.Move,
|
|
OrganizeAction.Move,
|
|
OrganizeAction.Move,
|
|
OrganizeAction.Move,
|
|
OrganizeAction.Skip,
|
|
OrganizeAction.Move,
|
|
OrganizeAction.Skip,
|
|
OrganizeAction.Skip,
|
|
OrganizeAction.Skip,
|
|
};
|
|
}
|
|
|
|
createdFolders = new List<string>();
|
|
}
|
|
|
|
private void OnDisable()
|
|
{
|
|
string data = JsonUtility.ToJson(this, false);
|
|
EditorPrefs.SetString(PrefsKey, data);
|
|
}
|
|
#endregion
|
|
#region Helper Methods
|
|
private static void Credit()
|
|
{
|
|
using (new GUILayout.HorizontalScope())
|
|
{
|
|
GUILayout.FlexibleSpace();
|
|
if (GUILayout.Button("Made By Dreadrith#3238", "boldlabel"))
|
|
Application.OpenURL("https://linktr.ee/Dreadrith");
|
|
}
|
|
}
|
|
|
|
private static bool ReadyPath(string folderPath)
|
|
{
|
|
if (Directory.Exists(folderPath)) return false;
|
|
|
|
Directory.CreateDirectory(folderPath);
|
|
AssetDatabase.ImportAsset(folderPath);
|
|
return true;
|
|
}
|
|
public static List<string> GetAssetPathsInFolder(string path, bool deep = true)
|
|
{
|
|
string[] fileEntries = Directory.GetFiles(path);
|
|
string[] subDirectories = deep ? AssetDatabase.GetSubFolders(path) : null;
|
|
|
|
List<string> list =
|
|
(from fileName in fileEntries
|
|
where !fileName.EndsWith(".meta")
|
|
select fileName.Replace('\\', '/')).ToList();
|
|
|
|
|
|
if (deep)
|
|
foreach (var sd in subDirectories)
|
|
list.AddRange(GetAssetPathsInFolder(sd));
|
|
|
|
|
|
return list;
|
|
}
|
|
#endregion
|
|
#endregion
|
|
|
|
#region Classes & Structs
|
|
|
|
[System.Serializable]
|
|
private class CustomFolder
|
|
{
|
|
public string name;
|
|
public bool active = true;
|
|
public OrganizeAction action;
|
|
public CustomFolder(){}
|
|
public CustomFolder(string newName, OrganizeAction action = OrganizeAction.Skip)
|
|
{
|
|
name = newName;
|
|
this.action = action;
|
|
}
|
|
}
|
|
|
|
|
|
private class DependencyAsset
|
|
{
|
|
public readonly Object asset;
|
|
public readonly string path;
|
|
public readonly Type type;
|
|
public readonly GUIContent icon;
|
|
public OrganizeAction action;
|
|
public OrganizeType associatedType;
|
|
|
|
public DependencyAsset(string path)
|
|
{
|
|
this.path = path;
|
|
asset = AssetDatabase.LoadAssetAtPath<Object>(path);
|
|
action = OrganizeAction.Skip;
|
|
type = asset.GetType();
|
|
icon = new GUIContent(AssetPreview.GetMiniTypeThumbnail(type), type.Name);
|
|
}
|
|
}
|
|
private readonly struct OrganizeType
|
|
{
|
|
public readonly int actionIndex;
|
|
public readonly string name;
|
|
public readonly Type[] associatedTypes;
|
|
private readonly string[] associatedExtensions;
|
|
|
|
public OrganizeType(int actionIndex, string name)
|
|
{
|
|
this.actionIndex = actionIndex;
|
|
this.name = name;
|
|
this.associatedTypes = Array.Empty<Type>();
|
|
this.associatedExtensions = Array.Empty<string>();
|
|
}
|
|
public OrganizeType(int actionIndex, string name, params string[] associatedTypes)
|
|
{
|
|
this.actionIndex = actionIndex;
|
|
this.name = name;
|
|
this.associatedTypes = new Type[associatedTypes.Length];
|
|
for (int i = 0; i < associatedTypes.Length; i++)
|
|
this.associatedTypes[i] = System.Type.GetType(associatedTypes[i]);
|
|
|
|
this.associatedExtensions = Array.Empty<string>();
|
|
}
|
|
|
|
public OrganizeType(int actionIndex, string name, params Type[] associatedTypes)
|
|
{
|
|
this.actionIndex = actionIndex;
|
|
this.name = name;
|
|
|
|
this.associatedTypes = associatedTypes;
|
|
this.associatedExtensions = Array.Empty<string>();
|
|
}
|
|
|
|
public OrganizeType(int actionIndex, string name, string[] associatedExtensions, params string[] associatedTypes)
|
|
{
|
|
this.actionIndex = actionIndex;
|
|
this.name = name;
|
|
|
|
this.associatedTypes = new Type[associatedTypes.Length];
|
|
for (int i = 0; i < associatedTypes.Length; i++)
|
|
this.associatedTypes[i] = System.Type.GetType(associatedTypes[i]);
|
|
|
|
this.associatedExtensions = associatedExtensions;
|
|
}
|
|
|
|
public OrganizeType(int actionIndex, string name, string[] associatedExtensions, params Type[] associatedTypes)
|
|
{
|
|
this.actionIndex = actionIndex;
|
|
this.name = name;
|
|
|
|
int count = associatedTypes.Length;
|
|
this.associatedTypes = associatedTypes;
|
|
this.associatedExtensions = associatedExtensions;
|
|
}
|
|
|
|
public bool IsAppliedTo(DependencyAsset a)
|
|
{
|
|
bool applies = a.type != null &&
|
|
(associatedTypes.Any(t => t != null && (a.type == t || a.type.IsSubclassOf(t)))
|
|
|| associatedExtensions.Any(e => !string.IsNullOrWhiteSpace(e) && a.path.EndsWith(e)));
|
|
|
|
return applies;
|
|
}
|
|
|
|
}
|
|
|
|
private class BGColoredScope : System.IDisposable
|
|
{
|
|
private readonly Color ogColor;
|
|
public BGColoredScope(Color setColor)
|
|
{
|
|
ogColor = GUI.backgroundColor;
|
|
GUI.backgroundColor = setColor;
|
|
}
|
|
public BGColoredScope(Color setColor, bool isActive)
|
|
{
|
|
ogColor = GUI.backgroundColor;
|
|
GUI.backgroundColor = isActive ? setColor : ogColor;
|
|
}
|
|
public BGColoredScope(Color active, Color inactive, bool isActive)
|
|
{
|
|
ogColor = GUI.backgroundColor;
|
|
GUI.backgroundColor = isActive ? active : inactive;
|
|
}
|
|
|
|
public BGColoredScope(int selectedIndex, params Color[] colors)
|
|
{
|
|
ogColor = GUI.backgroundColor;
|
|
GUI.backgroundColor = colors[selectedIndex];
|
|
}
|
|
public void Dispose()
|
|
{
|
|
GUI.backgroundColor = ogColor;
|
|
}
|
|
}
|
|
#endregion
|
|
}
|
|
}
|