bool CreateOrRestoreTool(CustomEditorTool customEditorTool, out EditorTool customEditorToolInstance)
{
var toolType = customEditorTool.editorToolType;
var toolOwner = customEditorTool.owner;
var targets = customEditorTool.targets;
var target = customEditorTool.owner.target;
var activeIsCustomEditorTool = IsCustomEditorTool(m_ActiveTool);
bool preservedActiveTool = false;
// 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 = targets;
m_ActiveTool.m_Target = 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 = targets;
((EditorTool)x).m_Target = target;
});
customEditorToolInstance.hideFlags = HideFlags.DontSave;
}
var editModeTool = customEditorToolInstance as EditModeTool;
if (editModeTool != null)
{
editModeTool.owner = toolOwner;
}
return(preservedActiveTool);
}
void RestoreCustomEditorTool()
{
var restored = m_ComponentTools.FirstOrDefault(m_PreviousComponentToolCache.IsEqual);
if (restored != null)
{
// todo Use generated Context
if (m_PreviousComponentToolCache.contextType != null)
{
activeToolContext = GetComponentContext(m_PreviousComponentToolCache.contextType);
}
activeTool = restored.GetEditor <EditorTool>();
}
m_PreviousComponentToolCache = ComponentToolCache.Empty;
}
static bool CustomEditorToolIsMatch(Editor editor, Type toolType, EditorTool tool)
{
if (editor == null || toolType != tool.GetType())
{
return(false);
}
// if it's an EditModeTool we need to be stricter about ownership for backwards compatibility.
var editModeTool = tool as EditModeTool;
if (editModeTool != null)
{
return(editModeTool.owner == (IToolModeOwner)editor || editModeTool.target == editor.target);
}
// otherwise just check if it's a valid type
return(true);
}
public bool IsEqual(EditorTool other)
{
if (editorToolType != (other == null ? null : other.GetType()))
{
return(false);
}
if (ReferenceEquals(targetObjects, other.m_Targets))
{
return(true);
}
if (targetObjects == null || other.m_Targets == null)
{
return(false);
}
return(targetObjects.SequenceEqual(other.m_Targets));
}
public CustomEditorToolContext(EditorTool tool)
{
if (tool != null)
{
editorToolType = tool.GetType();
targetObject = tool.target;
targetObjects = tool.targets.ToArray();
m_EditorToolState = EditorJsonUtility.ToJson(tool);
}
else
{
editorToolType = null;
targetObject = null;
targetObjects = null;
m_EditorToolState = null;
}
m_EditorToolType = null;
}
public ComponentToolCache(EditorToolContext context, EditorTool tool)
{
bool customTool = IsCustomEditorTool(tool);
bool customContext = IsCustomToolContext(context);
if (customTool || customContext)
{
toolType = customTool ? tool.GetType() : null;
contextType = customContext ? context.GetType() : null;
targetObject = tool.target;
targetObjects = tool.targets.ToArray();
}
else
{
toolType = null;
contextType = null;
targetObject = null;
targetObjects = null;
}
m_ToolType = null;
m_ContextType = null;
}
static bool IsCustomEditorTool(EditorTool tool)
{
return(EditorToolUtility.IsCustomEditorTool(tool != null ? tool.GetType() : null));
}
internal static string GetToolMenuPath(EditorTool tool)
{
return(GetToolMenuPath(tool != null ? tool.GetType() : typeof(EditorTool)));
}
public static bool IsActiveTool(EditorTool tool)
{
return(EditorToolManager.activeTool == tool);
}
public static void SetActiveTool(EditorTool tool)
{
EditorToolManager.activeTool = tool;
}
public static bool IsActiveTool(EditorTool tool)
{
return(EditorToolContext.activeTool == tool);
}
public static void SetActiveTool(EditorTool tool)
{
EditorToolContext.activeTool = tool;
}
public static bool IsActiveTool(EditorTool tool)
{
return(ToolManager.IsActiveTool(tool));
}
public static void SetActiveTool(EditorTool tool)
{
ToolManager.SetActiveTool(tool);
}
