Por lo general, diría que su pregunta es bastante amplia y el caso de uso es muy complicado y requiere muchos pasos no tan triviales para abordar. Pero veo que también te has esforzado bastante en la investigación y en tu pregunta, así que intentaré hacer lo mismo (pequeño regalo de Navidad);)

En general, creo que los genéricos no son lo que quieres usar aquí. Los genéricos siempre requieren parámetros constantes de tiempo de compilación.

Como solo estoy al teléfono y no sé, no puedo brindarle una solución completa en este momento, pero espero poder guiarlo por el camino correcto.

1. Interfaz común o clase base

Creo que lo más simple sería una interfaz común como, por ejemplo,

 public interface ITwoFloatOperation { public float GetResult(float a, float b); }

Por supuesto, también serviría una clase base abstract común. (Incluso podría optar por un determinado atributo en los métodos)

Y luego tener algunas implementaciones como por ejemplo

 public class Add : ITwoFloatOperation { public float GetResult(float a, float b) => a + b; } public class Multiply : ITwoFloatOperation { public float GetResult(float a, float b) => a * b; } public class Power : ITwoFloatOperation { public float GetResult(float a, float b) Mathf.Pow(a, b); } ... etc

2. Encuentra todas las implementaciones usando Reflection

Luego puede usar Reflection (ya estaba en el camino correcto allí) para encontrar automáticamente todas las implementaciones disponibles de esa interfaz como, por ejemplo, esta

 using System.Reflection; using System.Linq; ... var type = typeof(ITwoFloatOperation); var types = AppDomain.CurrentDomain.GetAssemblies() .SelectMany(s => s.GetTypes()) .Where(p => type.IsAssignableFrom(p));

3. Almacenar/Serializar un tipo seleccionado en Unity

Ahora tienes todos los tipos...

Sin embargo, para poder usarlos realmente dentro de Unity, necesitará una clase especial adicional que sea [Serializable] y pueda almacenar un tipo, por ejemplo, como

 [Serializable] // See https://docs.unity3d.com/ScriptReference/ISerializationCallbackReceiver.html public class SerializableType : ISerializationCallbackReceiver { private Type type; [SerializeField] private string typeName; public Type Type => type; public void OnBeforeSerialize() { typeName = type != null ? type.AssemblyQualifiedName : ""; } public void OnAfterDeserialize() { if(!string.NullOrWhiteSpace(typeName)) type = Type.GetType(typeName); } }

4. Selección del tipo de interfaz y dibujo del menú desplegable

Luego, dado que no desea escribir los nombres manualmente, necesitará un cajón especial para el menú desplegable con los tipos dados que implementan su interfaz (verá que estamos conectando los puntos).

Probablemente usaría un atributo como, por ejemplo

 [AttributeUsage(AttributeTarget.Field)] public ImplementsAttribute : PropertyAttribute { public Type baseType; public ImplementsAttribute (Type type) { baseType = type; } }

A continuación, podría exponer el campo como, por ejemplo

 [Implements(typeof (ITwoFloatOperation))] public SerializableType operationType;

y luego tener un cajón personalizado. Esto depende, por supuesto, de sus necesidades. Honestamente, mi conocimiento del editor de secuencias de comandos se basa más en MonoBehaviour, etc., así que solo espero que de alguna manera puedas traducir esto en tu gráfico.

Algo como por ejemplo

 [CustomPropertyDrawer(typeof(ImplementsAttribute))] public class ImplementsDrawer : PropertyDrawer { // Return the underlying type of s serialized property private static Type GetType(SerializedProperty property) { // A little bit hacky we first get the type of the object that has this field var parentType = property.serializedObject.targetObject.GetType(); // And then once again we use reflection to get the field via it's name again var fi = parentType.GetField(property.propertyPath); return fi.FieldType; } private static Type[] FindTypes (Type baseType) { var type = typeof(ITwoFloatOperation); var types = AppDomain.CurrentDomain.GetAssemblies() .SelectMany(s => s.GetTypes()) .Where(p => type.IsAssignableFrom(p)); return types.OrderBy(t => t.AssemblyQualifiedName).ToArray(); } public override void OnGUI(Rect position, SerializedProperty property, GUIContent label) { label = EditorGUI.BeginProperty(position, label, property); var implements = attribute as ImplementsAttribute; if (GetType(property) != typeof (SerializableType)) { EditorGUI.HelpBox(position, MessageType.Error, "Implements only works for SerializableType!"); return; } var typeNameProperty = property.FindPropertyRelative("typeName"); var options = FindTypes (implements.baseType); var guiOptions = options.Select(o => o.AssemblyQualifiedName).ToArray(); var currentType = string.IsNullOrWhiteSpace(typeNameProperty.stringValue) ? null : Type.GetType(typeNameProperty.stringValue); var currentIndex = options.FindIndex(o => o == curtentType); var newIndex = EditorGUI.Popup(position, label.text, currentIndex, guiOptions); var newTypeName = newIndex >= 0 ? options[newIndex] : ""; property.stringValue = newTypeName; EditorGUI.EndProperty(); } }

5. Usar el tipo para crear una instancia

Una vez que de alguna manera pueda almacenar y obtener el tipo deseado como último paso, queremos usarlo ^^

Nuevamente, la solución sería la reflexión y el Activator , que nos permite crear una instancia de cualquier tipo dinámico dado usando Activator.CreateInstance

así que una vez que tenga el campo, por ejemplo, haría

 var instance = (ITwoFloatOperation) Activator.CreateInstance(operationType.Type)); var result = instance.GetResult(floatA, floatB);

Una vez que todo esto esté configurado y funcione correctamente ( ^^ ), sus "usuarios"/desarrolladores pueden agregar nuevas operaciones tan simples como implementar su interfaz.

Enfoque alternativo: "Comportamientos programables"

Pensándolo más, creo que tengo otro, tal vez un enfoque un poco más simple.

¡Esta opción tal vez no sea lo que estaba buscando originalmente y no es un menú desplegable, sino que simplemente usaremos la ventana emergente de selección de objetos ya existente para los activos!

Podría usar algo que me gusta llamar "Comportamientos programables" y tener un ScriptableObject base como

 public abstract class TwoFloatOperation : ScriptableObject { public abstract float GetResult(float a, float b); }

Y luego implementaciones múltiples (nota: ¡todo esto tiene que estar en archivos diferentes!)

 [CreateAssetMenu (fileName = "Add", menuName = "TwoFloatOperations/Add")] public class Add : TwoFloatOperation { public float GetResult(float a, float b) => a + b; } [CreateAssetMenu (fileName = "Multiply", menuName = "TwoFloatOperations/Multiply")] public class Multiply : TwoFloatOperation { public float GetResult(float a, float b) => a * b; } [CreateAssetMenu (fileName = "Power", menuName = "TwoFloatOperations/Power"] public class Power : TwoFloatOperation { public float GetResult(float a, float b) Mathf.Pow(a, b); }

Luego, crea una instancia de cada vis ProjectView -> Haga clic con el botón derecho -> Create -> TwoFloatOperations

Una vez que hizo esto para cada tipo, simplemente puede exponer un campo de tipo

 public TwoFloatOperation operation;

y deja que Unity haga todo el trabajo de reflexión para encontrar instancias que implementen esto en los recursos.

Simplemente puede hacer clic en el pequeño punto junto al campo del objeto y Unity le mostrará una lista de todas las opciones disponibles e incluso puede usar la barra de búsqueda para encontrar una por nombre.

Ventaja:

• No se requiere una reflexión sucia, costosa y propensa a errores
• Básicamente, todo se basa en la funcionalidad ya incorporada del editor -> menos preocupaciones con la serialización, etc.

Desventaja:

• Esto rompe un poco con el concepto real detrás de ScriptableObject , ya que normalmente habría varias instancias con diferentes configuraciones, no solo una.
• Como puede ver, sus desarrolladores no solo tienen que heredar un determinado tipo, sino también agregar el atributo CreateAssetMenu y crear una instancia para poder usarlo.

Como dije al escribir esto en el teléfono, pero espero que esto ayude con su caso de uso y le dé una idea de cómo abordaría esto.