随笔- 79 文章- 0 评论- 20 阅读- 10万

Unity检视面板的继承方法研究 (一)

　　对于检视面板 Inspector 的面板继承方式对项目来说是很有必要的, 比如一个基类, 写了一个很好看的检视面板[CustomEditor(typeof(XXX))],

可是所有子类的面板无法直接继承这个CustomEditor, 有些人的解决方案是把子类写检视面板的代码独立出来, 然后子类面板直接去调用这些Layout,

非常浪费人力物力.

　　最近发现有个 DecoratorEditor 脚本, 它实现了对 Unity 自带检视面板的扩展, 看到它实现某个类型的面板Inspector的方法, 就是使用Editor.CreateEditor 这个API

创建了一个相应的Editor, 然后调用它的OnInspectorGUI() 方法来绘制原有面板的, 于是可以从这个地方着手.

　　从设计上来说 [CustomEditor(typeof(XXX))] 在耦合上并没有太多的耦合, Unity 开发组的想法应该就是一个Editor对应一个组件, 它们对应类型之间的继承关系不应该

互相影响, 保证泛用性和独立性.

　　原始的Editor脚本和类型是这样的:

基类 :

public class TestBaseClass : MonoBehaviour
{
    public float abc;
}
 
// 检视面板
[CustomEditor(typeof(TestBaseClass))]
public class TestBaseClassInspector : Editor
{
    TestBaseClass _target;
 
    private void OnEnable()
    {
        _target = target as TestBaseClass;
    }
 
    public override void OnInspectorGUI()
    {
        _target.abc = EditorGUILayout.FloatField("基类变量 : ", _target.abc);
    }
}

子类1 :

public class TestCamera : TestBaseClass
{
    public Camera cam;
}
 
// 检视面板
[CustomEditor(typeof(TestCamera))]
public class TestCameraInspector : Editor
{
    TestCamera _target = null;
 
    private void OnEnable()
    {
        _target = target as TestCamera;
    }
 
    public override void OnInspectorGUI()
    {
        base.OnInspectorGUI();
         
        _target.cam = EditorGUILayout.ObjectField("一次继承变量 : ", _target.cam, typeof(Camera), true) as Camera;
    }
}

子类2 :

public class TestUntiy : TestCamera
{
    public int hahah;
}
 
// 检视面板
[CustomEditor(typeof(TestUntiy))]
public class TestUntiyInspector : Editor
{
    TestUntiy _target = null;
 
    private void OnEnable()
    {
        _target = target as TestUntiy;
    }
 
    public override void OnInspectorGUI()
    {
        base.OnInspectorGUI();
 
        _target.hahah = EditorGUILayout.IntField("二次继承变量 : ", _target.hahah);
    }
}

1	`TestBaseClass`

1	`TestCamera : TestBaseClass`

1	`TestUntiy : TestCamera<br><br>非常简单的继承关系, TestUnity的检视面板如下, 没有继承关系`

　　那么在继承的设计上, 也应该遵循Unity的设计原则, 在继承类型 : Editor 以及 base.OnInspectorGUI(); 绘制基类方法上做文章.

如果使用简单的继承比如:

[CustomEditor(typeof(TestCamera))]
public class TestCameraInspector : TestBaseClassInspector
{
    TestCamera _target = null;
 
    private void OnEnable()
    {
        _target = target as TestCamera;
    }
 
    public override void OnInspectorGUI()
    {
        base.OnInspectorGUI();
 
        _target.cam = EditorGUILayout.ObjectField("一次继承变量 : ", _target.cam, typeof(Camera), true) as Camera;
    }
}

　　会出现很多问题, 如基类的OnEnable方法没有被触发, 基类面板报错等, 所有生命周期都要写虚方法, 每个重写方法都要注意, 很麻烦.

　　而Editor.CreateEditor创建的Editor是有生命周期的. 创建一个中间类型 InspectorDecoratorEditor, 大家都继承它就可以了, 而绘制基类对象的方法就改为

DrawBaseInspectorGUI<T>(), 这样就能方便地自己定义需要绘制的基类了.

public class InspectorDecoratorEditor : Editor
{
    public static readonly System.Type EndType = typeof(UnityEngine.MonoBehaviour);     // end type dont need show in inspector
    public static readonly System.Type BaseEditorType = typeof(UnityEditor.Editor);     // CustomEditor must inherit from it, filter
    public static readonly BindingFlags CustomEditorFieldFlags = BindingFlags.NonPublic | BindingFlags.Instance;    // flag
 
    // type cache[Assembly, [scriptType, customEditorType]]
    protected static Dictionary<Assembly, Dictionary<System.Type, System.Type>> ms_editorReferenceScript
        = new Dictionary<Assembly, Dictionary<System.Type, System.Type>>();
 
    protected List<Editor> m_inheritEditors = null;     // cached editors
 
    // ctor, use ctor instead Mono life circle, more user friendly 
    public InspectorDecoratorEditor()
    {
        CacheEditorReferenceScript();
    }
 
    #region Main Funcs
    /// <summary>
    /// Cache all CustomEditor in current Assembly
    /// </summary>
    protected void CacheEditorReferenceScript()
    {
        var editorAssembly = Assembly.GetAssembly(this.GetType());      // editor may in diferent assemblies
        if(ms_editorReferenceScript.ContainsKey(editorAssembly) == false)
        {
            Dictionary<System.Type, System.Type> cachedData = new Dictionary<System.Type, System.Type>();
            var types = editorAssembly.GetExportedTypes();
            foreach(var editorType in types)
            {
                if(editorType.IsSubclassOf(BaseEditorType))
                {
                    var scriptType = GetTypeFormCustomEditor(editorType);
                    if(scriptType != null)
                    {
                        cachedData[scriptType] = editorType;
                    }
                }
            }
            ms_editorReferenceScript[editorAssembly] = cachedData;
        }
    }
 
    /// <summary>
    /// Draw a Target Type Inspector, call OnInspectorGUI
    /// </summary>
    /// <typeparam name="T"></typeparam>
    protected virtual void DrawBaseInspectorGUI<T>() where T : InspectorDecoratorEditor
    {
        if(m_inheritEditors == null)
        {
            m_inheritEditors = new List<Editor>();
            Dictionary<System.Type, System.Type> scriptEditorCache = null;
            if(ms_editorReferenceScript.TryGetValue(Assembly.GetAssembly(this.GetType()), out scriptEditorCache) && scriptEditorCache != null)
            {
                var baseType = target.GetType().BaseType;
                while(baseType != null && baseType != EndType)
                {
                    System.Type editorType = null;
                    if(scriptEditorCache.TryGetValue(baseType, out editorType) && editorType != null)
                    {
                        m_inheritEditors.Add(Editor.CreateEditor(targets, editorType));
                    }
                    baseType = baseType.BaseType;
                }
            }
        }
        if(m_inheritEditors.Count > 0)
        {
            for(int i = m_inheritEditors.Count - 1; i >= 0; i--)
            {
                var drawTarget = m_inheritEditors[i];
                if(drawTarget && drawTarget.GetType() == typeof(T))
                {
                    drawTarget.OnInspectorGUI();   // draw target type only, avoid endless loop
                    break;
                }
            }
        }
    }
    #endregion
 
    #region Help Funcs
    public static System.Type GetTypeFormCustomEditor(System.Type editorType)
    {
        var attributes = editorType.GetCustomAttributes(typeof(CustomEditor), false) as CustomEditor[];
        if(attributes != null && attributes.Length > 0)
        {
            var attribute = attributes[0];
            var type = attribute.GetType().GetField("m_InspectedType", CustomEditorFieldFlags).GetValue(attribute) as System.Type;
            return type;
        }
        return null;
    }
    #endregion
}

　　修改后的Editor代码如下, 修改的只有继承类以及DrawBaseInspectorGUI<T>函数, 注意这里对于T来说是没有类型检查的, 可是在函数中是有类型匹配的,

就算传入错误类型也是安全的 :

[CustomEditor(typeof(TestBaseClass))]
public class TestBaseClassInspector : InspectorDecoratorEditor
{
    TestBaseClass _target;
 
    private void OnEnable()
    {
        _target = target as TestBaseClass;
    }
 
    public override void OnInspectorGUI()
    {
        _target.abc = EditorGUILayout.FloatField("基类变量 : ", _target.abc);
    }
}
 
[CustomEditor(typeof(TestCamera))]
public class TestCameraInspector : InspectorDecoratorEditor
{
    TestCamera _target = null;
 
    private void OnEnable()
    {
        _target = target as TestCamera;
    }
 
    public override void OnInspectorGUI()
    {
        DrawBaseInspectorGUI<TestBaseClassInspector>();
 
        _target.cam = EditorGUILayout.ObjectField("一次继承变量 : ", _target.cam, typeof(Camera), true) as Camera;
    }
}
 
[CustomEditor(typeof(TestUntiy))]
public class TestUntiyInspector : InspectorDecoratorEditor
{
    TestUntiy _target = null;
 
    private void OnEnable()
    {
        _target = target as TestUntiy;
    }
 
    public override void OnInspectorGUI()
    {
        DrawBaseInspectorGUI<TestCameraInspector>();
 
        _target.hahah = EditorGUILayout.IntField("二次继承变量 : ", _target.hahah);
    }
}

　　然后看看检视面板现在的样子, 完美绘制了基类面板:

DrawBaseInspectorGUI<T>() 这个绘制基类的请求强大的地方就是可以选择从哪个类型开始绘制, 比如
DrawBaseInspectorGUI<TestCameraInspector>();
换成
DrawBaseInspectorGUI<TestBaseClassInspector>();
那么 TestCameraInspector 这个检视面板就被跳过去了 :