setting.png
将脚本QuickToggle放置到Editor目标下
/*
Copyright 2017, Jeiel Aranal
Permission is hereby granted, free of charge, to any person obtaining a copy of this software
and associated documentation files (the "Software"), to deal in the Software without restriction,
including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial
portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH
THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
using System;
using System.Collections.Generic;
using System.Reflection;
using UnityEditor;
using UnityEngine;
using Object = UnityEngine.Object;
namespace SubjectNerd.QuickToggle
{
[InitializeOnLoad]
public class QuickToggle
{
#region Constants
private const string PrefKeyShowToggle = "UnityToolbag.QuickToggle.Visible";
private const string PrefKeyShowDividers = "UnityToolbag.QuickToggle.Dividers";
private const string PrefKeyShowIcons = "UnityToolbag.QuickToggle.Icons";
private const string PrefKeyGutterLevel = "UnityToolbag.QuickToggle.Gutter";
private const string MENU_NAME = "Window/Hierarchy Quick Toggle/Show Toggles";
private const string MENU_DIVIDER = "Window/Hierarchy Quick Toggle/Dividers";
private const string MENU_ICONS = "Window/Hierarchy Quick Toggle/Object Icons";
private const string MENU_GUTTER_0 = "Window/Hierarchy Quick Toggle/Right Gutter/0";
private const string MENU_GUTTER_1 = "Window/Hierarchy Quick Toggle/Right Gutter/1";
private const string MENU_GUTTER_2 = "Window/Hierarchy Quick Toggle/Right Gutter/2";
#endregion
private static readonly Type HierarchyWindowType;
private static readonly MethodInfo getObjectIcon;
private static bool stylesBuilt;
private static GUIStyle styleLock, styleUnlocked,
styleVisOn, styleVisOff,
styleDivider;
private static bool showDivider, showIcons;
#region Menu stuff
[MenuItem(MENU_NAME, false, 1)]
private static void QuickToggleMenu()
{
bool toggle = EditorPrefs.GetBool(PrefKeyShowToggle);
ShowQuickToggle(!toggle);
Menu.SetChecked(MENU_NAME, !toggle);
}
[MenuItem(MENU_NAME, true)]
private static bool SetupMenuCheckMarks()
{
Menu.SetChecked(MENU_NAME, EditorPrefs.GetBool(PrefKeyShowToggle));
Menu.SetChecked(MENU_DIVIDER, EditorPrefs.GetBool(PrefKeyShowDividers));
Menu.SetChecked(MENU_ICONS, EditorPrefs.GetBool(PrefKeyShowIcons));
int gutterLevel = EditorPrefs.GetInt(PrefKeyGutterLevel, 0);
gutterCount = gutterLevel;
UpdateGutterMenu(gutterCount);
return true;
}
[MenuItem(MENU_DIVIDER, false, 20)]
private static void ToggleDivider()
{
ToggleSettings(PrefKeyShowDividers, MENU_DIVIDER, out showDivider);
}
[MenuItem(MENU_ICONS, false, 21)]
private static void ToggleIcons()
{
ToggleSettings(PrefKeyShowIcons, MENU_ICONS, out showIcons);
}
private static void ToggleSettings(string prefKey, string menuString, out bool valueBool)
{
valueBool = !EditorPrefs.GetBool(prefKey);
EditorPrefs.SetBool(prefKey, valueBool);
Menu.SetChecked(menuString, valueBool);
EditorApplication.RepaintHierarchyWindow();
}
[MenuItem(MENU_GUTTER_0, false, 40)]
private static void SetGutter0() { SetGutterLevel(0); }
[MenuItem(MENU_GUTTER_1, false, 41)]
private static void SetGutter1() { SetGutterLevel(1); }
[MenuItem(MENU_GUTTER_2, false, 42)]
private static void SetGutter2() { SetGutterLevel(2); }
private static void SetGutterLevel(int gutterLevel)
{
gutterLevel = Mathf.Clamp(gutterLevel, 0, 2);
EditorPrefs.SetInt(PrefKeyGutterLevel, gutterLevel);
gutterCount = gutterLevel;
UpdateGutterMenu(gutterCount);
EditorApplication.RepaintHierarchyWindow();
}
private static void UpdateGutterMenu(int gutterLevel)
{
string[] gutterKeys = new[] { MENU_GUTTER_0, MENU_GUTTER_1, MENU_GUTTER_2 };
bool[] gutterValues = null;
switch (gutterLevel)
{
case 1:
gutterValues = new[] { false, true, false };
break;
case 2:
gutterValues = new[] { false, false, true };
break;
default:
gutterValues = new[] { true, false, false };
break;
}
for (int i = 0; i < gutterKeys.Length; i++)
{
string key = gutterKeys[i];
bool isChecked = gutterValues[i];
Menu.SetChecked(key, isChecked);
}
}
#endregion
static QuickToggle()
{
// Setup initial state of editor prefs if there are no prefs keys yet
string[] resetPrefs = new string[] { PrefKeyShowToggle, PrefKeyShowDividers, PrefKeyShowIcons };
foreach (string prefKey in resetPrefs)
{
if (EditorPrefs.HasKey(prefKey) == false)
EditorPrefs.SetBool(prefKey, false);
}
// Fetch some reflection/type stuff for use later on
Assembly editorAssembly = typeof(EditorWindow).Assembly;
HierarchyWindowType = editorAssembly.GetType("UnityEditor.SceneHierarchyWindow");
var flags = BindingFlags.InvokeMethod | BindingFlags.Static | BindingFlags.NonPublic;
Type editorGuiUtil = typeof(EditorGUIUtility);
getObjectIcon = editorGuiUtil.GetMethod("GetIconForObject", flags, null, new Type[] { typeof(UnityEngine.Object) }, null);
// Not calling BuildStyles() in constructor because script gets loaded
// on Unity initialization, styles might not be loaded yet
// Reset mouse state
ResetVars();
// Setup quick toggle
ShowQuickToggle(EditorPrefs.GetBool(PrefKeyShowToggle));
}
private static void ShowQuickToggle(bool show)
{
EditorPrefs.SetBool(PrefKeyShowToggle, show);
showDivider = EditorPrefs.GetBool(PrefKeyShowDividers, false);
showIcons = EditorPrefs.GetBool(PrefKeyShowIcons, false);
gutterCount = EditorPrefs.GetInt(PrefKeyGutterLevel);
if (show)
{
ResetVars();
EditorApplication.update += HandleEditorUpdate;
EditorApplication.hierarchyWindowItemOnGUI += DrawHierarchyItem;
}
else
{
EditorApplication.update -= HandleEditorUpdate;
EditorApplication.hierarchyWindowItemOnGUI -= DrawHierarchyItem;
}
EditorApplication.RepaintHierarchyWindow();
}
private struct PropagateState
{
public bool isVisibility;
public bool propagateValue;
public PropagateState(bool isVisibility, bool propagateValue)
{
this.isVisibility = isVisibility;
this.propagateValue = propagateValue;
}
}
private static PropagateState propagateState;
// Because we can't hook into OnGUI of HierarchyWindow, doing a hack
// button that involves the editor update loop and the hierarchy item draw event
private static bool isFrameFresh;
private static bool isMousePressed;
private static int gutterCount = 0;
private static void ResetVars()
{
isFrameFresh = false;
isMousePressed = false;
}
private static void HandleEditorUpdate()
{
EditorWindow window = EditorWindow.mouseOverWindow;
if (window == null)
{
ResetVars();
return;
}
if (window.GetType() == HierarchyWindowType)
{
if (window.wantsMouseMove == false)
window.wantsMouseMove = true;
isFrameFresh = true;
}
}
private static void DrawHierarchyItem(int instanceId, Rect selectionRect)
{
BuildStyles();
GameObject target = EditorUtility.InstanceIDToObject(instanceId) as GameObject;
if (target == null)
return;
// Reserve the draw rects
float gutterX = selectionRect.height * gutterCount;
if (gutterX > 0)
gutterX += selectionRect.height * 0.1f;
float xMax = selectionRect.xMax - gutterX;
Rect visRect = new Rect(selectionRect)
{
xMin = xMax - (selectionRect.height * 2.1f),
xMax = xMax - selectionRect.height
};
Rect lockRect = new Rect(selectionRect)
{
xMin = xMax - (selectionRect.height * 1.05f),
xMax = xMax - (selectionRect.height * 0.05f)
};
// Get states
bool isVisible = target.activeSelf;
bool isLocked = (target.hideFlags & HideFlags.NotEditable) > 0;
// Draw the visibility toggle
GUIStyle visStyle = (isVisible) ? styleVisOn : styleVisOff;
GUI.Label(visRect, GUIContent.none, visStyle);
// Draw lock toggle
GUIStyle lockStyle = (isLocked) ? styleLock : styleUnlocked;
GUI.Label(lockRect, GUIContent.none, lockStyle);
// Draw optional divider
if (showDivider)
{
Rect lineRect = new Rect(selectionRect)
{
yMin = selectionRect.yMax - 1f,
yMax = selectionRect.yMax + 2f
};
GUI.Label(lineRect, GUIContent.none, styleDivider);
}
// Draw optional object icons
if (showIcons && getObjectIcon != null)
{
Texture2D iconImg = getObjectIcon.Invoke(null, new object[] { target }) as Texture2D;
if (iconImg != null)
{
Rect iconRect = new Rect(selectionRect)
{
xMin = visRect.xMin - 30,
xMax = visRect.xMin - 5
};
GUI.DrawTexture(iconRect, iconImg, ScaleMode.ScaleToFit);
}
}
if (Event.current == null)
return;
HandleMouse(target, isVisible, isLocked, visRect, lockRect);
}
private static void HandleMouse(GameObject target, bool isVisible, bool isLocked, Rect visRect, Rect lockRect)
{
Event evt = Event.current;
bool toggleActive = visRect.Contains(evt.mousePosition);
bool toggleLock = lockRect.Contains(evt.mousePosition);
bool stateChanged = (toggleActive || toggleLock);
bool doMouse = false;
switch (evt.type)
{
case EventType.MouseDown:
// Checking is frame fresh so mouse state is only tested once per frame
// instead of every time a hierarchy item is drawn
bool isMouseDown = false;
if (isFrameFresh && stateChanged)
{
isMouseDown = !isMousePressed;
isMousePressed = true;
isFrameFresh = false;
}
if (stateChanged && isMouseDown)
{
doMouse = true;
if (toggleActive) isVisible = !isVisible;
if (toggleLock) isLocked = !isLocked;
propagateState = new PropagateState(toggleActive, (toggleActive) ? isVisible : isLocked);
evt.Use();
}
break;
case EventType.MouseDrag:
doMouse = isMousePressed;
break;
case EventType.DragPerform:
case EventType.DragExited:
case EventType.DragUpdated:
case EventType.MouseUp:
ResetVars();
break;
}
if (doMouse && stateChanged)
{
if (propagateState.isVisibility)
SetVisible(target, propagateState.propagateValue);
else
SetLockObject(target, propagateState.propagateValue);
EditorApplication.RepaintHierarchyWindow();
}
}
private static Object[] GatherObjects(GameObject root)
{
List<UnityEngine.Object> objects = new List<UnityEngine.Object>();
Stack<GameObject> recurseStack = new Stack<GameObject>(new GameObject[] { root });
while (recurseStack.Count > 0)
{
GameObject obj = recurseStack.Pop();
objects.Add(obj);
foreach (Transform childT in obj.transform)
recurseStack.Push(childT.gameObject);
}
return objects.ToArray();
}
private static void SetLockObject(GameObject target, bool isLocked)
{
bool objectLockState = (target.hideFlags & HideFlags.NotEditable) > 0;
if (objectLockState == isLocked)
return;
Object[] objects = GatherObjects(target);
foreach (Object obj in objects)
{
GameObject go = (GameObject)obj;
string undoString = string.Format("{0} {1}", isLocked ? "Lock" : "Unlock", go.name);
Undo.RecordObject(go, undoString);
// Set state according to isLocked
if (isLocked)
{
go.hideFlags |= HideFlags.NotEditable;
}
else
{
go.hideFlags &= ~HideFlags.NotEditable;
}
// Set hideflags of components
foreach (Component comp in go.GetComponents<Component>())
{
if (comp is Transform)
continue;
Undo.RecordObject(comp, undoString);
if (isLocked)
{
comp.hideFlags |= HideFlags.NotEditable;
comp.hideFlags |= HideFlags.HideInHierarchy;
}
else
{
comp.hideFlags &= ~HideFlags.NotEditable;
comp.hideFlags &= ~HideFlags.HideInHierarchy;
}
EditorUtility.SetDirty(comp);
}
EditorUtility.SetDirty(go);
}
Undo.IncrementCurrentGroup();
}
private static void SetVisible(GameObject target, bool isActive)
{
if (target.activeSelf == isActive) return;
string undoString = string.Format("{0} {1}",
isActive ? "Show" : "Hide",
target.name);
Undo.RecordObject(target, undoString);
target.SetActive(isActive);
EditorUtility.SetDirty(target);
}
private static void BuildStyles()
{
// All of the styles have been built, don't do anything
if (stylesBuilt)
return;
// Now build the GUI styles
// Using icons different from regular lock button so that
// it would look darker
var tempStyle = GUI.skin.FindStyle("IN LockButton");
styleLock = new GUIStyle(tempStyle)
{
normal = tempStyle.onNormal,
active = tempStyle.onActive,
hover = tempStyle.onHover,
focused = tempStyle.onFocused,
};
// Unselected just makes the normal states have no lock images
tempStyle = GUI.skin.FindStyle("OL Toggle");
styleUnlocked = new GUIStyle(tempStyle);
tempStyle = GUI.skin.FindStyle("VisibilityToggle");
styleVisOff = new GUIStyle(tempStyle);
styleVisOn = new GUIStyle(tempStyle)
{
normal = new GUIStyleState() { background = tempStyle.onNormal.background }
};
styleDivider = GUI.skin.FindStyle("EyeDropperHorizontalLine");
stylesBuilt = (styleLock != null && styleUnlocked != null &&
styleVisOn != null && styleVisOff != null &&
styleDivider != null);
}
}
}
