void RebuildAvailableTools()
{
ComponentToolCache activeComponentTool = new ComponentToolCache(m_ActiveToolContext, activeTool);
ClearCustomEditorTools();
EditorToolUtility.InstantiateComponentTools(activeToolContext, m_ComponentTools);
if (activeComponentTool.toolType != null)
{
var restoredTool = m_ComponentTools.Find(x => x.editorType == activeComponentTool.toolType);
if (restoredTool != null)
{
activeTool = restoredTool.GetEditor <EditorTool>();
}
else
{
m_PreviousComponentToolCache = activeComponentTool;
RestorePreviousPersistentTool();
}
}
availableComponentToolsChanged?.Invoke();
}
internal static void OnToolGUI(EditorWindow window)
{
activeToolContext.OnToolGUI(window);
if (Tools.s_Hidden || instance.m_ActiveTool == null)
{
return;
}
var current = instance.m_ActiveTool;
using (new EditorGUI.DisabledScope(!current.IsAvailable()))
{
current.OnToolGUI(window);
}
var evt = Event.current;
if (evt.type == EventType.KeyDown && evt.keyCode == KeyCode.Escape)
{
if (!Tools.viewToolActive &&
!EditorToolUtility.IsManipulationTool(EditorToolUtility.GetEnumWithEditorTool(current, instance.m_ActiveToolContext)) &&
additionalContextToolTypesCache.All(toolType => toolType != current.GetType()))
{
RestorePreviousPersistentTool();
evt.Use();
}
else
{
//if is in a Manipulation or additional tool leaves the current context to return to GameObject Context
ToolManager.SetActiveContext <GameObjectToolContext>();
}
}
}
public static void SetActiveTool(Type type)
{
if (!typeof(EditorTool).IsAssignableFrom(type) || type.IsAbstract)
{
throw new ArgumentException("Type must be assignable to EditorTool, and not abstract.");
}
var attrib = EditorToolUtility.GetEditorToolAttribute(type);
if (attrib?.targetType != null)
{
var tool = EditorToolContext.GetCustomEditorToolOfType(type);
if (tool == null)
{
throw new InvalidOperationException("The current selection does not contain any objects editable by the CustomEditor tool \"" + type + ".\"");
}
SetActiveTool(tool);
return;
}
SetActiveTool(EditorToolContext.GetSingleton(type));
}
public static void RestorePreviousTool()
{
var prev = EditorToolUtility.GetEditorToolWithEnum(EditorToolManager.previousTool);
if (!(prev is NoneTool))
{
EditorToolManager.activeTool = prev;
}
}
bool CollectCustomEditorToolsFromTracker(ActiveEditorTracker tracker, List <EditorTool> list)
{
list.Clear();
var activeIsCustomEditorTool = IsCustomEditorTool(m_ActiveTool);
var preservedActiveTool = false;
EditorToolUtility.GetEditorToolsForTracker(tracker, s_CustomEditorTools);
foreach (var customEditorTool in s_CustomEditorTools)
{
var toolType = customEditorTool.editorToolType;
var toolOwner = customEditorTool.owner;
EditorTool customEditorToolInstance;
// The only case where a custom editor tool is serialized is when it is the active tool. All other
// instances are discarded and rebuilt on any tracker rebuild.
if (activeIsCustomEditorTool && CustomEditorToolIsMatch(toolOwner, toolType, m_ActiveTool))
{
preservedActiveTool = true;
m_ActiveTool.m_Targets = toolOwner.targets;
m_ActiveTool.m_Target = toolOwner.target;
// domain reload - the owning editor was destroyed and therefore we need to reset the EditMode active
if (m_ActiveTool is EditModeTool && toolOwner.GetInstanceID() != UnityEditorInternal.EditMode.ownerID)
{
UnityEditorInternal.EditMode.EditModeToolStateChanged(toolOwner, ((EditModeTool)m_ActiveTool).editMode);
}
customEditorToolInstance = m_ActiveTool;
}
else
{
customEditorToolInstance = (EditorTool)CreateInstance(toolType, x =>
{
((EditorTool)x).m_Targets = toolOwner.targets;
((EditorTool)x).m_Target = toolOwner.target;
});
customEditorToolInstance.hideFlags = HideFlags.DontSave;
}
list.Add(customEditorToolInstance);
var editModeTool = customEditorToolInstance as EditModeTool;
if (editModeTool != null)
{
editModeTool.owner = toolOwner;
}
}
return(preservedActiveTool);
}
internal static EditorTool GetLastCustomTool()
{
for (int i = instance.m_ToolHistory.Count - 1; i > -1; i--)
{
if (EditorToolUtility.GetEnumWithEditorTool(instance.m_ToolHistory[i]) == Tool.Custom)
{
return(instance.m_ToolHistory[i]);
}
}
return(null);
}
void ToolChanged()
{
if (m_Editor != null)
{
DestroyImmediate(m_Editor);
}
var activeTool = EditorToolContext.activeTool;
m_Editor = Editor.CreateEditor(activeTool);
titleContent = new GUIContent(EditorToolUtility.GetToolName(activeTool.GetType()));
Repaint();
}
internal static void GetToolHistory(List <EditorTool> tools, bool customToolsOnly = false)
{
tools.Clear();
instance.CleanupToolHistory();
for (int i = instance.m_ToolHistory.Count - 1; i > -1; i--)
{
if (!customToolsOnly || EditorToolUtility.GetEnumWithEditorTool(instance.m_ToolHistory[i]) == Tool.Custom)
{
tools.Add(instance.m_ToolHistory[i]);
}
}
}
void RebuildAvailableContexts()
{
var activeContextType = activeToolContext.GetType();
ClearComponentContexts();
EditorToolUtility.InstantiateComponentContexts(m_ComponentContexts);
var restoredContext = m_ComponentContexts.Find(x => x.editorType == activeContextType);
if (restoredContext != null)
{
activeToolContext = restoredContext.GetEditor <EditorToolContext>();
}
}
public static void RestorePreviousPersistentTool()
{
var last = EditorToolContext.GetLastTool(x => x && !EditorToolUtility.IsCustomEditorTool(x.GetType()));
if (last != null)
{
SetActiveTool(last);
}
else
{
SetActiveTool <MoveTool>();
}
}
public UnityObject InstantiateEditor()
{
var toolType = editorType;
m_Editor = ScriptableObject.CreateInstance(toolType, x =>
{
((IEditor)x).SetTargets(targets);
((IEditor)x).SetTarget(target);
});
m_Editor.hideFlags = HideFlags.DontSave;
if (m_Editor is EditorToolContext)
{
m_EditorToolScope = EditorToolScope.ToolContext;
}
else if (m_Editor is EditorTool tool &&
EditorToolUtility.GetEnumWithEditorTool(tool, EditorToolManager.activeToolContext) != Tool.Custom)
{
m_EditorToolScope = EditorToolScope.ManipulationToolOverride;
}
public static void SetActiveTool(Type type)
{
if (!typeof(EditorTool).IsAssignableFrom(type) || type.IsAbstract)
{
throw new ArgumentException("Type must be assignable to EditorTool, and not abstract.");
}
if (EditorToolUtility.IsComponentEditor(type))
{
var tool = EditorToolManager.GetComponentTool(type);
if (tool == null)
{
throw new InvalidOperationException("The current selection does not contain any objects editable " +
$"by the component tool of type: {type}");
}
SetActiveTool(tool);
return;
}
SetActiveTool((EditorTool)EditorToolManager.GetSingleton(type));
}
internal static EditorTool GetCustomEditorToolsForType(Type targetType, List <EditorTool> list, bool searchLockedInspectors)
{
foreach (var customEditorTool in instance.m_CustomEditorTools)
{
if (customEditorTool != null &&
EditorToolUtility.GetCustomEditorToolTargetType(customEditorTool) == targetType)
{
list.Add(customEditorTool);
}
}
if (searchLockedInspectors)
{
foreach (var customEditorTool in instance.m_LockedCustomEditorTools)
{
if (customEditorTool != null && EditorToolUtility.GetCustomEditorToolTargetType(customEditorTool) == targetType)
{
list.Add(customEditorTool);
}
}
}
return(null);
}
public static void SetActiveContext(Type context)
{
if (context != null && (!typeof(EditorToolContext).IsAssignableFrom(context) || context.IsAbstract))
{
throw new ArgumentException("Type must be assignable to EditorToolContext, and not abstract.", "context");
}
var ctx = context != null ? context : typeof(GameObjectToolContext);
if (EditorToolUtility.IsComponentEditor(ctx))
{
var instance = EditorToolManager.GetComponentContext(ctx);
if (instance == null)
{
throw new InvalidOperationException("The current selection does not contain any objects editable " +
$"by the component tool of type: {context}");
}
EditorToolManager.activeToolContext = instance;
}
else
{
EditorToolManager.activeToolContext = EditorToolManager.GetSingleton(ctx) as EditorToolContext;
}
}
static bool IsCustomEditorTool(EditorTool tool)
{
return(EditorToolUtility.IsCustomEditorTool(tool != null ? tool.GetType() : null));
}
void RebuildAvailableCustomEditorTools()
{
EditorApplication.delayCall -= RebuildAvailableCustomEditorTools;
// Do not rebuild the cache since objects are serialized, destroyed, deserialized during this phase
if (m_PlayModeState == PlayModeStateChange.ExitingEditMode ||
m_PlayModeState == PlayModeStateChange.ExitingPlayMode)
{
return;
}
var preservedActiveTool = false;
ClearCustomEditorTools();
var inspectors = InspectorWindow.GetInspectors();
// If the shared tracker is locked, use our own tracker instance so that the current selection is always
// represented. Addresses case where a single locked inspector is open.
var shared = ActiveEditorTracker.sharedTracker;
m_CustomEditorTools.Clear();
m_LockedCustomEditorTools.Clear();
// Collect editor tools for the shared tracker first
EditorToolUtility.GetEditorToolsForTracker(shared.isLocked ? tracker : shared, s_CustomEditorTools);
foreach (var customEditorTool in s_CustomEditorTools)
{
if (m_CustomEditorTools.Any(x => x.GetType() == customEditorTool.editorToolType && x.target == customEditorTool.owner.target))
{
continue;
}
EditorTool tool;
preservedActiveTool |= CreateOrRestoreTool(customEditorTool, out tool);
m_CustomEditorTools.Add(tool);
}
// Next, collect tools from locked inspectors
foreach (var inspector in inspectors)
{
if (inspector.isLocked)
{
EditorToolUtility.GetEditorToolsForTracker(inspector.tracker, s_CustomEditorTools);
foreach (var customEditorTool in s_CustomEditorTools)
{
// Don't add duplicate tools to either another locked inspector with the same target, or a shared tracker
if (m_CustomEditorTools.Any(x => x.GetType() == customEditorTool.editorToolType && x.target == customEditorTool.owner.target) ||
m_LockedCustomEditorTools.Any(x => x.GetType() == customEditorTool.editorToolType && x.target == customEditorTool.owner.target))
{
continue;
}
EditorTool tool;
preservedActiveTool |= CreateOrRestoreTool(customEditorTool, out tool);
m_LockedCustomEditorTools.Add(tool);
}
}
}
if (IsCustomEditorTool(m_ActiveTool) && !preservedActiveTool)
{
var previous = m_ActiveTool;
m_PreviousCustomEditorToolContext = new CustomEditorToolContext(m_ActiveTool);
RestorePreviousTool();
DestroyImmediate(previous);
}
}