Unity

1using UnityEngine;
2using UnityEditor;
3using UnityEditorInternal;
4using System;
5using UnityEngine.Events;
6
7[CustomEditor(typeof(SequenceManager))]
8public class SequenceManagerEditor : Editor
9{
10    SerializedProperty Sequences;
11
12    ReorderableList list;
13    private void OnEnable()
14    {
15        Sequences = serializedObject.FindProperty("Sequences");
16        list = new ReorderableList(serializedObject, Sequences, true, true, true, true);
17        list.drawElementCallback = DrawListItems;
18        list.drawHeaderCallback = DrawHeader;
19        list.elementHeightCallback = ElementHeight;
20    }
21
22    //Draws the elements in the list
23    void DrawListItems(Rect rect, int index, bool isActive, bool isFocused)
24    {
25        SerializedProperty element = list.serializedProperty.GetArrayElementAtIndex(index);
26        
27
28        ////NAME
29        EditorGUI.LabelField(new Rect(
30            rect.x, 
31            rect.y + EditorGUIUtility.standardVerticalSpacing, 
32            50, 
33            EditorGUIUtility.singleLineHeight), "Name");
34        EditorGUI.PropertyField(
35            new Rect(
36                rect.x + 50, 
37                rect.y + EditorGUIUtility.standardVerticalSpacing, 
38                rect.width - 50, 
39                EditorGUIUtility.singleLineHeight),
40            element.FindPropertyRelative("Name"),
41            GUIContent.none
42            );
43
44        //ON INIT
45            EditorGUI.LabelField(new Rect(
46            rect.x, 
47            rect.y + EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing * 3, 
48            50, 
49            EditorGUIUtility.singleLineHeight), "OnInit");
50        EditorGUI.PropertyField(new Rect(
51                rect.x + 50, 
52                rect.y + EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing * 3, 
53                rect.width - 50, 
54                3 * rect.y + 5 * EditorGUIUtility.singleLineHeight),
55            element.FindPropertyRelative("OnInit"),
56            GUIContent.none);
57
58        //ON DONE
59        EditorGUI.LabelField(new Rect(
60            rect.x, 
61            rect.y + 7 * EditorGUIUtility.singleLineHeight, 
62            50, 
63            EditorGUIUtility.singleLineHeight), "OnDone");
64        EditorGUI.PropertyField(
65            new Rect(
66                rect.x + 50, 
67                rect.y + 7 * EditorGUIUtility.singleLineHeight, 
68                rect.width - 50, 
69                3 * rect.y + 12 * EditorGUIUtility.singleLineHeight),
70               element.FindPropertyRelative("OnDone"),
71            GUIContent.none);
72
73        SerializedProperty indexProperty = element.FindPropertyRelative("index");
74        indexProperty.intValue = index;
75    }
76
77    private float ElementHeight(int index)
78    {
79        return (13 * EditorGUIUtility.singleLineHeight);
80    }
81
82    //Draws the header
83    void DrawHeader(Rect rect)
84    {
85        string name = "Sequences";
86        EditorGUI.LabelField(rect, name);
87    }
88
89
90    public override void OnInspectorGUI()
91    {
92        //base.OnInspectorGUI();
93        serializedObject.Update();
94        this.list.DoLayoutList();
95        serializedObject.ApplyModifiedProperties();
96     }    
97 }
98using UnityEngine;
99using UnityEditor;
100using System;
101using UnityEngine.Events;
102
103[Serializable]
104public class Sequence
105{
106    public string Name;
107    public UnityEvent OnInit;
108    public UnityEvent OnDone;
109    private Module _module;
110    public int index;
111    private bool active;
112
113    //Called By The Sequence Manager At the start of a sequence 
114    internal void Init(Module p_module)
115    {
116        Debug.Log($"sequence: {Name} with index: {index} has started");
117        active = true;
118        _module = p_module;
119         if(OnInit.HasNoListners())
120        {
121            Done();
122        } 
123        else
124        {
125            OnInit.Invoke();
126        }
127    }
128    
129    
130    //Called Manually to Trigger the End of the Sequence
131    internal void Done()
132    {
133        if (!OnDone.HasNoListners())
134        {
135            OnDone.Invoke();
136        }
137        active = false;
138        Debug.Log($"sequence: {Name} with index: {index} is done");
139        _module.FinishedSequence(index);
140    }
141
142    //Check if active
143    internal bool GetActive()
144    {
145        return active;
146    }
147}
148
149using System;
150namespace UnityEngine
151{
152    [Serializable]
153    public class SequenceManager: MonoBehaviour
154    {
155       
156        #region Properties
157        public Sequence[] Sequences;
158        #endregion
159    }
160}
161if(target is not SequenceManager manager)
162{
163    //target was not a SequenceManager, the manager variable will be null
164    return;
165}
166

1using UnityEngine;
2using UnityEditor;
3using UnityEditorInternal;
4using System;
5using UnityEngine.Events;
6
7[CustomEditor(typeof(SequenceManager))]
8public class SequenceManagerEditor : Editor
9{
10    SerializedProperty Sequences;
11
12    ReorderableList list;
13    private void OnEnable()
14    {
15        Sequences = serializedObject.FindProperty("Sequences");
16        list = new ReorderableList(serializedObject, Sequences, true, true, true, true);
17        list.drawElementCallback = DrawListItems;
18        list.drawHeaderCallback = DrawHeader;
19        list.elementHeightCallback = ElementHeight;
20    }
21
22    //Draws the elements in the list
23    void DrawListItems(Rect rect, int index, bool isActive, bool isFocused)
24    {
25        SerializedProperty element = list.serializedProperty.GetArrayElementAtIndex(index);
26        
27
28        ////NAME
29        EditorGUI.LabelField(new Rect(
30            rect.x, 
31            rect.y + EditorGUIUtility.standardVerticalSpacing, 
32            50, 
33            EditorGUIUtility.singleLineHeight), "Name");
34        EditorGUI.PropertyField(
35            new Rect(
36                rect.x + 50, 
37                rect.y + EditorGUIUtility.standardVerticalSpacing, 
38                rect.width - 50, 
39                EditorGUIUtility.singleLineHeight),
40            element.FindPropertyRelative("Name"),
41            GUIContent.none
42            );
43
44        //ON INIT
45            EditorGUI.LabelField(new Rect(
46            rect.x, 
47            rect.y + EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing * 3, 
48            50, 
49            EditorGUIUtility.singleLineHeight), "OnInit");
50        EditorGUI.PropertyField(new Rect(
51                rect.x + 50, 
52                rect.y + EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing * 3, 
53                rect.width - 50, 
54                3 * rect.y + 5 * EditorGUIUtility.singleLineHeight),
55            element.FindPropertyRelative("OnInit"),
56            GUIContent.none);
57
58        //ON DONE
59        EditorGUI.LabelField(new Rect(
60            rect.x, 
61            rect.y + 7 * EditorGUIUtility.singleLineHeight, 
62            50, 
63            EditorGUIUtility.singleLineHeight), "OnDone");
64        EditorGUI.PropertyField(
65            new Rect(
66                rect.x + 50, 
67                rect.y + 7 * EditorGUIUtility.singleLineHeight, 
68                rect.width - 50, 
69                3 * rect.y + 12 * EditorGUIUtility.singleLineHeight),
70               element.FindPropertyRelative("OnDone"),
71            GUIContent.none);
72
73        SerializedProperty indexProperty = element.FindPropertyRelative("index");
74        indexProperty.intValue = index;
75    }
76
77    private float ElementHeight(int index)
78    {
79        return (13 * EditorGUIUtility.singleLineHeight);
80    }
81
82    //Draws the header
83    void DrawHeader(Rect rect)
84    {
85        string name = "Sequences";
86        EditorGUI.LabelField(rect, name);
87    }
88
89
90    public override void OnInspectorGUI()
91    {
92        //base.OnInspectorGUI();
93        serializedObject.Update();
94        this.list.DoLayoutList();
95        serializedObject.ApplyModifiedProperties();
96     }    
97 }
98using UnityEngine;
99using UnityEditor;
100using System;
101using UnityEngine.Events;
102
103[Serializable]
104public class Sequence
105{
106    public string Name;
107    public UnityEvent OnInit;
108    public UnityEvent OnDone;
109    private Module _module;
110    public int index;
111    private bool active;
112
113    //Called By The Sequence Manager At the start of a sequence 
114    internal void Init(Module p_module)
115    {
116        Debug.Log($"sequence: {Name} with index: {index} has started");
117        active = true;
118        _module = p_module;
119         if(OnInit.HasNoListners())
120        {
121            Done();
122        } 
123        else
124        {
125            OnInit.Invoke();
126        }
127    }
128    
129    
130    //Called Manually to Trigger the End of the Sequence
131    internal void Done()
132    {
133        if (!OnDone.HasNoListners())
134        {
135            OnDone.Invoke();
136        }
137        active = false;
138        Debug.Log($"sequence: {Name} with index: {index} is done");
139        _module.FinishedSequence(index);
140    }
141
142    //Check if active
143    internal bool GetActive()
144    {
145        return active;
146    }
147}
148
149using System;
150namespace UnityEngine
151{
152    [Serializable]
153    public class SequenceManager: MonoBehaviour
154    {
155       
156        #region Properties
157        public Sequence[] Sequences;
158        #endregion
159    }
160}
161if(target is not SequenceManager manager)
162{
163    //target was not a SequenceManager, the manager variable will be null
164    return;
165}
166var sequence = manager.Sequences[index];
167var size = sequence.OnInit.GetPersistentEventCount()
168         + sequence.OnDone.GetPersistentEventCount();
169

1using UnityEngine;
2using UnityEditor;
3using UnityEditorInternal;
4using System;
5using UnityEngine.Events;
6
7[CustomEditor(typeof(SequenceManager))]
8public class SequenceManagerEditor : Editor
9{
10    SerializedProperty Sequences;
11
12    ReorderableList list;
13    private void OnEnable()
14    {
15        Sequences = serializedObject.FindProperty("Sequences");
16        list = new ReorderableList(serializedObject, Sequences, true, true, true, true);
17        list.drawElementCallback = DrawListItems;
18        list.drawHeaderCallback = DrawHeader;
19        list.elementHeightCallback = ElementHeight;
20    }
21
22    //Draws the elements in the list
23    void DrawListItems(Rect rect, int index, bool isActive, bool isFocused)
24    {
25        SerializedProperty element = list.serializedProperty.GetArrayElementAtIndex(index);
26        
27
28        ////NAME
29        EditorGUI.LabelField(new Rect(
30            rect.x, 
31            rect.y + EditorGUIUtility.standardVerticalSpacing, 
32            50, 
33            EditorGUIUtility.singleLineHeight), "Name");
34        EditorGUI.PropertyField(
35            new Rect(
36                rect.x + 50, 
37                rect.y + EditorGUIUtility.standardVerticalSpacing, 
38                rect.width - 50, 
39                EditorGUIUtility.singleLineHeight),
40            element.FindPropertyRelative("Name"),
41            GUIContent.none
42            );
43
44        //ON INIT
45            EditorGUI.LabelField(new Rect(
46            rect.x, 
47            rect.y + EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing * 3, 
48            50, 
49            EditorGUIUtility.singleLineHeight), "OnInit");
50        EditorGUI.PropertyField(new Rect(
51                rect.x + 50, 
52                rect.y + EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing * 3, 
53                rect.width - 50, 
54                3 * rect.y + 5 * EditorGUIUtility.singleLineHeight),
55            element.FindPropertyRelative("OnInit"),
56            GUIContent.none);
57
58        //ON DONE
59        EditorGUI.LabelField(new Rect(
60            rect.x, 
61            rect.y + 7 * EditorGUIUtility.singleLineHeight, 
62            50, 
63            EditorGUIUtility.singleLineHeight), "OnDone");
64        EditorGUI.PropertyField(
65            new Rect(
66                rect.x + 50, 
67                rect.y + 7 * EditorGUIUtility.singleLineHeight, 
68                rect.width - 50, 
69                3 * rect.y + 12 * EditorGUIUtility.singleLineHeight),
70               element.FindPropertyRelative("OnDone"),
71            GUIContent.none);
72
73        SerializedProperty indexProperty = element.FindPropertyRelative("index");
74        indexProperty.intValue = index;
75    }
76
77    private float ElementHeight(int index)
78    {
79        return (13 * EditorGUIUtility.singleLineHeight);
80    }
81
82    //Draws the header
83    void DrawHeader(Rect rect)
84    {
85        string name = "Sequences";
86        EditorGUI.LabelField(rect, name);
87    }
88
89
90    public override void OnInspectorGUI()
91    {
92        //base.OnInspectorGUI();
93        serializedObject.Update();
94        this.list.DoLayoutList();
95        serializedObject.ApplyModifiedProperties();
96     }    
97 }
98using UnityEngine;
99using UnityEditor;
100using System;
101using UnityEngine.Events;
102
103[Serializable]
104public class Sequence
105{
106    public string Name;
107    public UnityEvent OnInit;
108    public UnityEvent OnDone;
109    private Module _module;
110    public int index;
111    private bool active;
112
113    //Called By The Sequence Manager At the start of a sequence 
114    internal void Init(Module p_module)
115    {
116        Debug.Log($"sequence: {Name} with index: {index} has started");
117        active = true;
118        _module = p_module;
119         if(OnInit.HasNoListners())
120        {
121            Done();
122        } 
123        else
124        {
125            OnInit.Invoke();
126        }
127    }
128    
129    
130    //Called Manually to Trigger the End of the Sequence
131    internal void Done()
132    {
133        if (!OnDone.HasNoListners())
134        {
135            OnDone.Invoke();
136        }
137        active = false;
138        Debug.Log($"sequence: {Name} with index: {index} is done");
139        _module.FinishedSequence(index);
140    }
141
142    //Check if active
143    internal bool GetActive()
144    {
145        return active;
146    }
147}
148
149using System;
150namespace UnityEngine
151{
152    [Serializable]
153    public class SequenceManager: MonoBehaviour
154    {
155       
156        #region Properties
157        public Sequence[] Sequences;
158        #endregion
159    }
160}
161if(target is not SequenceManager manager)
162{
163    //target was not a SequenceManager, the manager variable will be null
164    return;
165}
166var sequence = manager.Sequences[index];
167var size = sequence.OnInit.GetPersistentEventCount()
168         + sequence.OnDone.GetPersistentEventCount();
169var element = list.serializedProperty.GetArrayElementAtIndex(index);
170var size = element.FindPropertyRelative("OnInit.m_PersistentCalls.m_Calls").arraySize
171         + element.FindPropertyRelative("OnDone.m_PersistentCalls.m_Calls").arraySize;
172

1public async void PrintNumberWithAwait()
2{
3    int number = await GetNumber();
4    Debug.Log(number); //Successfully prints "5"
5}
6
7public void PrintNumberWithResult()
8{
9    int number = GetNumber().Result;
10    Debug.Log(number); //Application Freezes
11}
12
13private async Task<int> GetNumber()
14{
15    await Task.Delay(1000);
16    return 5;
17}
18PrintNumberWithAwait();
19PrintNumberWithResult();
20public async void PrintNumberWithAwait()
21

1public async void PrintNumberWithAwait()
2{
3    int number = await GetNumber();
4    Debug.Log(number); //Successfully prints "5"
5}
6
7public void PrintNumberWithResult()
8{
9    int number = GetNumber().Result;
10    Debug.Log(number); //Application Freezes
11}
12
13private async Task<int> GetNumber()
14{
15    await Task.Delay(1000);
16    return 5;
17}
18PrintNumberWithAwait();
19PrintNumberWithResult();
20public async void PrintNumberWithAwait()
21public async Task PrintNumberWithAwait()
22{
23    int number = await GetNumber();
24    Debug.Log(number); //Successfully prints "5"
25}
26
27

1public async void PrintNumberWithAwait()
2{
3    int number = await GetNumber();
4    Debug.Log(number); //Successfully prints "5"
5}
6
7public void PrintNumberWithResult()
8{
9    int number = GetNumber().Result;
10    Debug.Log(number); //Application Freezes
11}
12
13private async Task<int> GetNumber()
14{
15    await Task.Delay(1000);
16    return 5;
17}
18PrintNumberWithAwait();
19PrintNumberWithResult();
20public async void PrintNumberWithAwait()
21public async Task PrintNumberWithAwait()
22{
23    int number = await GetNumber();
24    Debug.Log(number); //Successfully prints "5"
25}
26
27await PrintNumberWithAwait();
28

1public async void PrintNumberWithAwait()
2{
3    int number = await GetNumber();
4    Debug.Log(number); //Successfully prints "5"
5}
6
7public void PrintNumberWithResult()
8{
9    int number = GetNumber().Result;
10    Debug.Log(number); //Application Freezes
11}
12
13private async Task<int> GetNumber()
14{
15    await Task.Delay(1000);
16    return 5;
17}
18PrintNumberWithAwait();
19PrintNumberWithResult();
20public async void PrintNumberWithAwait()
21public async Task PrintNumberWithAwait()
22{
23    int number = await GetNumber();
24    Debug.Log(number); //Successfully prints "5"
25}
26
27await PrintNumberWithAwait();
28Task t = PrintNumberWithAwait();
29// Do other stuff
30// ...
31await t;
32

1base <- function(b, base = 10)
2{
3  base <- as.integer(base)
4  if(base > 36 | base < 2) stop("'base' must be between 2 and 36.")
5  
6  structure(lapply(b, function(x) 
7    {
8      n   <- ceiling(log(x, base))
9      vec <- numeric()
10      val <- x
11      
12      while(n >= 0)
13      {
14        rem <- val %/% base^n
15        val <- val - rem * base^n
16        vec <- c(vec, rem)
17        n <- n - 1
18      }
19      
20      while(vec[1] == 0 & length(vec) > 1) vec <- vec[-1]
21      structure(x, base = base, representation = vec) 
22    }), class = "base")
23}
24base(1/8, base = 60, digits = 6)
25[[1]]
26[1] 0.125
27attr(,"base")
28[1] 60
29attr(,"representation")
30[1]  7 29 59 59 59 59
31
32attr(,"class")
33[1] "base"
34

1base <- function(b, base = 10)
2{
3  base <- as.integer(base)
4  if(base > 36 | base < 2) stop("'base' must be between 2 and 36.")
5  
6  structure(lapply(b, function(x) 
7    {
8      n   <- ceiling(log(x, base))
9      vec <- numeric()
10      val <- x
11      
12      while(n >= 0)
13      {
14        rem <- val %/% base^n
15        val <- val - rem * base^n
16        vec <- c(vec, rem)
17        n <- n - 1
18      }
19      
20      while(vec[1] == 0 & length(vec) > 1) vec <- vec[-1]
21      structure(x, base = base, representation = vec) 
22    }), class = "base")
23}
24base(1/8, base = 60, digits = 6)
25[[1]]
26[1] 0.125
27attr(,"base")
28[1] 60
29attr(,"representation")
30[1]  7 29 59 59 59 59
31
32attr(,"class")
33[1] "base"
34base <- function(b, base = 10, digits = 0) {
35  base <- as.integer(base)
36  structure(lapply(b, function(x)
37    {
38      n   <- ceiling(log(x, base))
39      vec <- numeric()
40      val <- x
41
42      while(n >= -1*digits )  {
43        rem <- val %/% base^n
44        val <- val - rem * base^n
45        vec <- c(vec, rem)
46        n <- n - 1
47      }
48
49      while(vec[1] == 0 & length(vec) > 1) vec <- vec[-1]
50      structure(x, base = base, representation = vec)
51    }), class = "base")
52}
53

1... snip ...
2
3        // OperatorSelection.GetSelections() is automagically populated by inheritors of the GenericOperation class
4        // So it would represent a collection of types?
5        // so the confusion is primarily around what type this should be
6        public GenericOperations /* ?? */ MathOperations = GenericOperation.GetOperations();
7
8        // this gets assigned by the editor when the user clicks 
9        // the dropdown, but I'm unclear on what the type should
10        // be since it can be one of several types
11        // from the MathOperations collection
12        public Operation /* ?? */ operation;
13        
14        public override object GetValue(NodePort port)
15        {
16            float a = GetInputValue<float>("a", this.a);
17            float b = GetInputValue<float>("b", this.b);
18            result = 0f;
19            result = operation(a, b);
20            return result;
21        }
22
23... snip ...
24
25class GenericOperation:
26
27    @classmethod
28    def get_operations(cls):
29        return cls.__subclasses__()
30
31
32class AddOperation(GenericOperation):
33
34    def __call__(self, a, b):
35        return a + b
36
37
38if __name__ == '__main__':
39    op = AddOperation()
40    res = op(1, 2)
41    print(res)  # 3
42    print(GenericOperation.get_operations())  # {<class '__main__.AddOperation'>}
43
44public interface ITwoFloatOperation
45{
46    public float GetResult(float a, float b);
47}
48

1... snip ...
2
3        // OperatorSelection.GetSelections() is automagically populated by inheritors of the GenericOperation class
4        // So it would represent a collection of types?
5        // so the confusion is primarily around what type this should be
6        public GenericOperations /* ?? */ MathOperations = GenericOperation.GetOperations();
7
8        // this gets assigned by the editor when the user clicks 
9        // the dropdown, but I'm unclear on what the type should
10        // be since it can be one of several types
11        // from the MathOperations collection
12        public Operation /* ?? */ operation;
13        
14        public override object GetValue(NodePort port)
15        {
16            float a = GetInputValue<float>("a", this.a);
17            float b = GetInputValue<float>("b", this.b);
18            result = 0f;
19            result = operation(a, b);
20            return result;
21        }
22
23... snip ...
24
25class GenericOperation:
26
27    @classmethod
28    def get_operations(cls):
29        return cls.__subclasses__()
30
31
32class AddOperation(GenericOperation):
33
34    def __call__(self, a, b):
35        return a + b
36
37
38if __name__ == '__main__':
39    op = AddOperation()
40    res = op(1, 2)
41    print(res)  # 3
42    print(GenericOperation.get_operations())  # {<class '__main__.AddOperation'>}
43
44public interface ITwoFloatOperation
45{
46    public float GetResult(float a, float b);
47}
48public class Add : ITwoFloatOperation
49{
50    public float GetResult(float a, float b) => a + b;
51}
52
53public class Multiply : ITwoFloatOperation
54{
55    public float GetResult(float a, float b) => a * b;
56}
57
58public class Power : ITwoFloatOperation
59{
60    public float GetResult(float a, float b) Mathf.Pow(a, b);
61}
62
63... etc
64

1... snip ...
2
3        // OperatorSelection.GetSelections() is automagically populated by inheritors of the GenericOperation class
4        // So it would represent a collection of types?
5        // so the confusion is primarily around what type this should be
6        public GenericOperations /* ?? */ MathOperations = GenericOperation.GetOperations();
7
8        // this gets assigned by the editor when the user clicks 
9        // the dropdown, but I'm unclear on what the type should
10        // be since it can be one of several types
11        // from the MathOperations collection
12        public Operation /* ?? */ operation;
13        
14        public override object GetValue(NodePort port)
15        {
16            float a = GetInputValue<float>("a", this.a);
17            float b = GetInputValue<float>("b", this.b);
18            result = 0f;
19            result = operation(a, b);
20            return result;
21        }
22
23... snip ...
24
25class GenericOperation:
26
27    @classmethod
28    def get_operations(cls):
29        return cls.__subclasses__()
30
31
32class AddOperation(GenericOperation):
33
34    def __call__(self, a, b):
35        return a + b
36
37
38if __name__ == '__main__':
39    op = AddOperation()
40    res = op(1, 2)
41    print(res)  # 3
42    print(GenericOperation.get_operations())  # {<class '__main__.AddOperation'>}
43
44public interface ITwoFloatOperation
45{
46    public float GetResult(float a, float b);
47}
48public class Add : ITwoFloatOperation
49{
50    public float GetResult(float a, float b) => a + b;
51}
52
53public class Multiply : ITwoFloatOperation
54{
55    public float GetResult(float a, float b) => a * b;
56}
57
58public class Power : ITwoFloatOperation
59{
60    public float GetResult(float a, float b) Mathf.Pow(a, b);
61}
62
63... etc
64using System.Reflection;
65using System.Linq;
66
67...
68
69var type = typeof(ITwoFloatOperation);
70var types = AppDomain.CurrentDomain.GetAssemblies()
71    .SelectMany(s => s.GetTypes())
72    .Where(p => type.IsAssignableFrom(p));
73

1... snip ...
2
3        // OperatorSelection.GetSelections() is automagically populated by inheritors of the GenericOperation class
4        // So it would represent a collection of types?
5        // so the confusion is primarily around what type this should be
6        public GenericOperations /* ?? */ MathOperations = GenericOperation.GetOperations();
7
8        // this gets assigned by the editor when the user clicks 
9        // the dropdown, but I'm unclear on what the type should
10        // be since it can be one of several types
11        // from the MathOperations collection
12        public Operation /* ?? */ operation;
13        
14        public override object GetValue(NodePort port)
15        {
16            float a = GetInputValue<float>("a", this.a);
17            float b = GetInputValue<float>("b", this.b);
18            result = 0f;
19            result = operation(a, b);
20            return result;
21        }
22
23... snip ...
24
25class GenericOperation:
26
27    @classmethod
28    def get_operations(cls):
29        return cls.__subclasses__()
30
31
32class AddOperation(GenericOperation):
33
34    def __call__(self, a, b):
35        return a + b
36
37
38if __name__ == '__main__':
39    op = AddOperation()
40    res = op(1, 2)
41    print(res)  # 3
42    print(GenericOperation.get_operations())  # {<class '__main__.AddOperation'>}
43
44public interface ITwoFloatOperation
45{
46    public float GetResult(float a, float b);
47}
48public class Add : ITwoFloatOperation
49{
50    public float GetResult(float a, float b) => a + b;
51}
52
53public class Multiply : ITwoFloatOperation
54{
55    public float GetResult(float a, float b) => a * b;
56}
57
58public class Power : ITwoFloatOperation
59{
60    public float GetResult(float a, float b) Mathf.Pow(a, b);
61}
62
63... etc
64using System.Reflection;
65using System.Linq;
66
67...
68
69var type = typeof(ITwoFloatOperation);
70var types = AppDomain.CurrentDomain.GetAssemblies()
71    .SelectMany(s => s.GetTypes())
72    .Where(p => type.IsAssignableFrom(p));
73[Serializable]
74// See https://docs.unity3d.com/ScriptReference/ISerializationCallbackReceiver.html
75public class SerializableType : ISerializationCallbackReceiver
76{
77    private Type type;
78    [SerializeField] private string typeName;
79
80    public Type Type => type;
81
82    public void OnBeforeSerialize()
83    {
84        typeName = type != null ? type.AssemblyQualifiedName : "";
85    }
86
87    public void OnAfterDeserialize()
88    {
89        if(!string.NullOrWhiteSpace(typeName)) type = Type.GetType(typeName);
90    }
91}
92

1... snip ...
2
3        // OperatorSelection.GetSelections() is automagically populated by inheritors of the GenericOperation class
4        // So it would represent a collection of types?
5        // so the confusion is primarily around what type this should be
6        public GenericOperations /* ?? */ MathOperations = GenericOperation.GetOperations();
7
8        // this gets assigned by the editor when the user clicks 
9        // the dropdown, but I'm unclear on what the type should
10        // be since it can be one of several types
11        // from the MathOperations collection
12        public Operation /* ?? */ operation;
13        
14        public override object GetValue(NodePort port)
15        {
16            float a = GetInputValue<float>("a", this.a);
17            float b = GetInputValue<float>("b", this.b);
18            result = 0f;
19            result = operation(a, b);
20            return result;
21        }
22
23... snip ...
24
25class GenericOperation:
26
27    @classmethod
28    def get_operations(cls):
29        return cls.__subclasses__()
30
31
32class AddOperation(GenericOperation):
33
34    def __call__(self, a, b):
35        return a + b
36
37
38if __name__ == '__main__':
39    op = AddOperation()
40    res = op(1, 2)
41    print(res)  # 3
42    print(GenericOperation.get_operations())  # {<class '__main__.AddOperation'>}
43
44public interface ITwoFloatOperation
45{
46    public float GetResult(float a, float b);
47}
48public class Add : ITwoFloatOperation
49{
50    public float GetResult(float a, float b) => a + b;
51}
52
53public class Multiply : ITwoFloatOperation
54{
55    public float GetResult(float a, float b) => a * b;
56}
57
58public class Power : ITwoFloatOperation
59{
60    public float GetResult(float a, float b) Mathf.Pow(a, b);
61}
62
63... etc
64using System.Reflection;
65using System.Linq;
66
67...
68
69var type = typeof(ITwoFloatOperation);
70var types = AppDomain.CurrentDomain.GetAssemblies()
71    .SelectMany(s => s.GetTypes())
72    .Where(p => type.IsAssignableFrom(p));
73[Serializable]
74// See https://docs.unity3d.com/ScriptReference/ISerializationCallbackReceiver.html
75public class SerializableType : ISerializationCallbackReceiver
76{
77    private Type type;
78    [SerializeField] private string typeName;
79
80    public Type Type => type;
81
82    public void OnBeforeSerialize()
83    {
84        typeName = type != null ? type.AssemblyQualifiedName : "";
85    }
86
87    public void OnAfterDeserialize()
88    {
89        if(!string.NullOrWhiteSpace(typeName)) type = Type.GetType(typeName);
90    }
91}
92[AttributeUsage(AttributeTarget.Field)]
93public ImplementsAttribute : PropertyAttribute
94{
95    public Type baseType;
96
97    public ImplementsAttribute (Type type)
98    {
99        baseType = type;
100    }
101}
102

1... snip ...
2
3        // OperatorSelection.GetSelections() is automagically populated by inheritors of the GenericOperation class
4        // So it would represent a collection of types?
5        // so the confusion is primarily around what type this should be
6        public GenericOperations /* ?? */ MathOperations = GenericOperation.GetOperations();
7
8        // this gets assigned by the editor when the user clicks 
9        // the dropdown, but I'm unclear on what the type should
10        // be since it can be one of several types
11        // from the MathOperations collection
12        public Operation /* ?? */ operation;
13        
14        public override object GetValue(NodePort port)
15        {
16            float a = GetInputValue<float>("a", this.a);
17            float b = GetInputValue<float>("b", this.b);
18            result = 0f;
19            result = operation(a, b);
20            return result;
21        }
22
23... snip ...
24
25class GenericOperation:
26
27    @classmethod
28    def get_operations(cls):
29        return cls.__subclasses__()
30
31
32class AddOperation(GenericOperation):
33
34    def __call__(self, a, b):
35        return a + b
36
37
38if __name__ == '__main__':
39    op = AddOperation()
40    res = op(1, 2)
41    print(res)  # 3
42    print(GenericOperation.get_operations())  # {<class '__main__.AddOperation'>}
43
44public interface ITwoFloatOperation
45{
46    public float GetResult(float a, float b);
47}
48public class Add : ITwoFloatOperation
49{
50    public float GetResult(float a, float b) => a + b;
51}
52
53public class Multiply : ITwoFloatOperation
54{
55    public float GetResult(float a, float b) => a * b;
56}
57
58public class Power : ITwoFloatOperation
59{
60    public float GetResult(float a, float b) Mathf.Pow(a, b);
61}
62
63... etc
64using System.Reflection;
65using System.Linq;
66
67...
68
69var type = typeof(ITwoFloatOperation);
70var types = AppDomain.CurrentDomain.GetAssemblies()
71    .SelectMany(s => s.GetTypes())
72    .Where(p => type.IsAssignableFrom(p));
73[Serializable]
74// See https://docs.unity3d.com/ScriptReference/ISerializationCallbackReceiver.html
75public class SerializableType : ISerializationCallbackReceiver
76{
77    private Type type;
78    [SerializeField] private string typeName;
79
80    public Type Type => type;
81
82    public void OnBeforeSerialize()
83    {
84        typeName = type != null ? type.AssemblyQualifiedName : "";
85    }
86
87    public void OnAfterDeserialize()
88    {
89        if(!string.NullOrWhiteSpace(typeName)) type = Type.GetType(typeName);
90    }
91}
92[AttributeUsage(AttributeTarget.Field)]
93public ImplementsAttribute : PropertyAttribute
94{
95    public Type baseType;
96
97    public ImplementsAttribute (Type type)
98    {
99        baseType = type;
100    }
101}
102[Implements(typeof (ITwoFloatOperation))]
103public SerializableType operationType;
104

1... snip ...
2
3        // OperatorSelection.GetSelections() is automagically populated by inheritors of the GenericOperation class
4        // So it would represent a collection of types?
5        // so the confusion is primarily around what type this should be
6        public GenericOperations /* ?? */ MathOperations = GenericOperation.GetOperations();
7
8        // this gets assigned by the editor when the user clicks 
9        // the dropdown, but I'm unclear on what the type should
10        // be since it can be one of several types
11        // from the MathOperations collection
12        public Operation /* ?? */ operation;
13        
14        public override object GetValue(NodePort port)
15        {
16            float a = GetInputValue<float>("a", this.a);
17            float b = GetInputValue<float>("b", this.b);
18            result = 0f;
19            result = operation(a, b);
20            return result;
21        }
22
23... snip ...
24
25class GenericOperation:
26
27    @classmethod
28    def get_operations(cls):
29        return cls.__subclasses__()
30
31
32class AddOperation(GenericOperation):
33
34    def __call__(self, a, b):
35        return a + b
36
37
38if __name__ == '__main__':
39    op = AddOperation()
40    res = op(1, 2)
41    print(res)  # 3
42    print(GenericOperation.get_operations())  # {<class '__main__.AddOperation'>}
43
44public interface ITwoFloatOperation
45{
46    public float GetResult(float a, float b);
47}
48public class Add : ITwoFloatOperation
49{
50    public float GetResult(float a, float b) => a + b;
51}
52
53public class Multiply : ITwoFloatOperation
54{
55    public float GetResult(float a, float b) => a * b;
56}
57
58public class Power : ITwoFloatOperation
59{
60    public float GetResult(float a, float b) Mathf.Pow(a, b);
61}
62
63... etc
64using System.Reflection;
65using System.Linq;
66
67...
68
69var type = typeof(ITwoFloatOperation);
70var types = AppDomain.CurrentDomain.GetAssemblies()
71    .SelectMany(s => s.GetTypes())
72    .Where(p => type.IsAssignableFrom(p));
73[Serializable]
74// See https://docs.unity3d.com/ScriptReference/ISerializationCallbackReceiver.html
75public class SerializableType : ISerializationCallbackReceiver
76{
77    private Type type;
78    [SerializeField] private string typeName;
79
80    public Type Type => type;
81
82    public void OnBeforeSerialize()
83    {
84        typeName = type != null ? type.AssemblyQualifiedName : "";
85    }
86
87    public void OnAfterDeserialize()
88    {
89        if(!string.NullOrWhiteSpace(typeName)) type = Type.GetType(typeName);
90    }
91}
92[AttributeUsage(AttributeTarget.Field)]
93public ImplementsAttribute : PropertyAttribute
94{
95    public Type baseType;
96
97    public ImplementsAttribute (Type type)
98    {
99        baseType = type;
100    }
101}
102[Implements(typeof (ITwoFloatOperation))]
103public SerializableType operationType;
104 [CustomPropertyDrawer(typeof(ImplementsAttribute))]
105public class ImplementsDrawer : PropertyDrawer
106{
107    // Return the underlying type of s serialized property
108    private static Type GetType(SerializedProperty property)
109    {
110        // A little bit hacky we first get the type of the object that has this field
111        var parentType = property.serializedObject.targetObject.GetType();
112        // And then once again we use reflection to get the field via it's name again
113        var fi = parentType.GetField(property.propertyPath);
114        return fi.FieldType;
115    }
116
117    private static Type[] FindTypes (Type baseType)
118    {
119        var type = typeof(ITwoFloatOperation);
120        var types = AppDomain.CurrentDomain.GetAssemblies()
121            .SelectMany(s => s.GetTypes())
122            .Where(p => type.IsAssignableFrom(p));
123
124        return types.OrderBy(t => t.AssemblyQualifiedName).ToArray();
125    }
126
127    public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
128    {   
129        label = EditorGUI.BeginProperty(position, label, property);
130
131        var implements = attribute as ImplementsAttribute;
132
133        if (GetType(property) != typeof (SerializableType))
134        {
135            EditorGUI.HelpBox(position, MessageType.Error, "Implements only works for SerializableType!");
136            return;
137        }
138
139        var typeNameProperty = property.FindPropertyRelative("typeName");
140
141        var options = FindTypes (implements.baseType);
142
143        var guiOptions = options.Select(o => o.AssemblyQualifiedName).ToArray();
144
145        var currentType = string.IsNullOrWhiteSpace(typeNameProperty.stringValue) ? null : Type.GetType(typeNameProperty.stringValue);
146
147        var currentIndex = options.FindIndex(o => o == curtentType);
148
149        var newIndex = EditorGUI.Popup(position, label.text, currentIndex, guiOptions);
150
151        var newTypeName = newIndex >= 0 ? options[newIndex] : "";
152       
153        property.stringValue = newTypeName;   
154        EditorGUI.EndProperty();  
155    }
156}
157

1... snip ...
2
3        // OperatorSelection.GetSelections() is automagically populated by inheritors of the GenericOperation class
4        // So it would represent a collection of types?
5        // so the confusion is primarily around what type this should be
6        public GenericOperations /* ?? */ MathOperations = GenericOperation.GetOperations();
7
8        // this gets assigned by the editor when the user clicks 
9        // the dropdown, but I'm unclear on what the type should
10        // be since it can be one of several types
11        // from the MathOperations collection
12        public Operation /* ?? */ operation;
13        
14        public override object GetValue(NodePort port)
15        {
16            float a = GetInputValue<float>("a", this.a);
17            float b = GetInputValue<float>("b", this.b);
18            result = 0f;
19            result = operation(a, b);
20            return result;
21        }
22
23... snip ...
24
25class GenericOperation:
26
27    @classmethod
28    def get_operations(cls):
29        return cls.__subclasses__()
30
31
32class AddOperation(GenericOperation):
33
34    def __call__(self, a, b):
35        return a + b
36
37
38if __name__ == '__main__':
39    op = AddOperation()
40    res = op(1, 2)
41    print(res)  # 3
42    print(GenericOperation.get_operations())  # {<class '__main__.AddOperation'>}
43
44public interface ITwoFloatOperation
45{
46    public float GetResult(float a, float b);
47}
48public class Add : ITwoFloatOperation
49{
50    public float GetResult(float a, float b) => a + b;
51}
52
53public class Multiply : ITwoFloatOperation
54{
55    public float GetResult(float a, float b) => a * b;
56}
57
58public class Power : ITwoFloatOperation
59{
60    public float GetResult(float a, float b) Mathf.Pow(a, b);
61}
62
63... etc
64using System.Reflection;
65using System.Linq;
66
67...
68
69var type = typeof(ITwoFloatOperation);
70var types = AppDomain.CurrentDomain.GetAssemblies()
71    .SelectMany(s => s.GetTypes())
72    .Where(p => type.IsAssignableFrom(p));
73[Serializable]
74// See https://docs.unity3d.com/ScriptReference/ISerializationCallbackReceiver.html
75public class SerializableType : ISerializationCallbackReceiver
76{
77    private Type type;
78    [SerializeField] private string typeName;
79
80    public Type Type => type;
81
82    public void OnBeforeSerialize()
83    {
84        typeName = type != null ? type.AssemblyQualifiedName : "";
85    }
86
87    public void OnAfterDeserialize()
88    {
89        if(!string.NullOrWhiteSpace(typeName)) type = Type.GetType(typeName);
90    }
91}
92[AttributeUsage(AttributeTarget.Field)]
93public ImplementsAttribute : PropertyAttribute
94{
95    public Type baseType;
96
97    public ImplementsAttribute (Type type)
98    {
99        baseType = type;
100    }
101}
102[Implements(typeof (ITwoFloatOperation))]
103public SerializableType operationType;
104 [CustomPropertyDrawer(typeof(ImplementsAttribute))]
105public class ImplementsDrawer : PropertyDrawer
106{
107    // Return the underlying type of s serialized property
108    private static Type GetType(SerializedProperty property)
109    {
110        // A little bit hacky we first get the type of the object that has this field
111        var parentType = property.serializedObject.targetObject.GetType();
112        // And then once again we use reflection to get the field via it's name again
113        var fi = parentType.GetField(property.propertyPath);
114        return fi.FieldType;
115    }
116
117    private static Type[] FindTypes (Type baseType)
118    {
119        var type = typeof(ITwoFloatOperation);
120        var types = AppDomain.CurrentDomain.GetAssemblies()
121            .SelectMany(s => s.GetTypes())
122            .Where(p => type.IsAssignableFrom(p));
123
124        return types.OrderBy(t => t.AssemblyQualifiedName).ToArray();
125    }
126
127    public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
128    {   
129        label = EditorGUI.BeginProperty(position, label, property);
130
131        var implements = attribute as ImplementsAttribute;
132
133        if (GetType(property) != typeof (SerializableType))
134        {
135            EditorGUI.HelpBox(position, MessageType.Error, "Implements only works for SerializableType!");
136            return;
137        }
138
139        var typeNameProperty = property.FindPropertyRelative("typeName");
140
141        var options = FindTypes (implements.baseType);
142
143        var guiOptions = options.Select(o => o.AssemblyQualifiedName).ToArray();
144
145        var currentType = string.IsNullOrWhiteSpace(typeNameProperty.stringValue) ? null : Type.GetType(typeNameProperty.stringValue);
146
147        var currentIndex = options.FindIndex(o => o == curtentType);
148
149        var newIndex = EditorGUI.Popup(position, label.text, currentIndex, guiOptions);
150
151        var newTypeName = newIndex >= 0 ? options[newIndex] : "";
152       
153        property.stringValue = newTypeName;   
154        EditorGUI.EndProperty();  
155    }
156}
157var instance = (ITwoFloatOperation) Activator.CreateInstance(operationType.Type));
158var result = instance.GetResult(floatA, floatB);
159

1... snip ...
2
3        // OperatorSelection.GetSelections() is automagically populated by inheritors of the GenericOperation class
4        // So it would represent a collection of types?
5        // so the confusion is primarily around what type this should be
6        public GenericOperations /* ?? */ MathOperations = GenericOperation.GetOperations();
7
8        // this gets assigned by the editor when the user clicks 
9        // the dropdown, but I'm unclear on what the type should
10        // be since it can be one of several types
11        // from the MathOperations collection
12        public Operation /* ?? */ operation;
13        
14        public override object GetValue(NodePort port)
15        {
16            float a = GetInputValue<float>("a", this.a);
17            float b = GetInputValue<float>("b", this.b);
18            result = 0f;
19            result = operation(a, b);
20            return result;
21        }
22
23... snip ...
24
25class GenericOperation:
26
27    @classmethod
28    def get_operations(cls):
29        return cls.__subclasses__()
30
31
32class AddOperation(GenericOperation):
33
34    def __call__(self, a, b):
35        return a + b
36
37
38if __name__ == '__main__':
39    op = AddOperation()
40    res = op(1, 2)
41    print(res)  # 3
42    print(GenericOperation.get_operations())  # {<class '__main__.AddOperation'>}
43
44public interface ITwoFloatOperation
45{
46    public float GetResult(float a, float b);
47}
48public class Add : ITwoFloatOperation
49{
50    public float GetResult(float a, float b) => a + b;
51}
52
53public class Multiply : ITwoFloatOperation
54{
55    public float GetResult(float a, float b) => a * b;
56}
57
58public class Power : ITwoFloatOperation
59{
60    public float GetResult(float a, float b) Mathf.Pow(a, b);
61}
62
63... etc
64using System.Reflection;
65using System.Linq;
66
67...
68
69var type = typeof(ITwoFloatOperation);
70var types = AppDomain.CurrentDomain.GetAssemblies()
71    .SelectMany(s => s.GetTypes())
72    .Where(p => type.IsAssignableFrom(p));
73[Serializable]
74// See https://docs.unity3d.com/ScriptReference/ISerializationCallbackReceiver.html
75public class SerializableType : ISerializationCallbackReceiver
76{
77    private Type type;
78    [SerializeField] private string typeName;
79
80    public Type Type => type;
81
82    public void OnBeforeSerialize()
83    {
84        typeName = type != null ? type.AssemblyQualifiedName : "";
85    }
86
87    public void OnAfterDeserialize()
88    {
89        if(!string.NullOrWhiteSpace(typeName)) type = Type.GetType(typeName);
90    }
91}
92[AttributeUsage(AttributeTarget.Field)]
93public ImplementsAttribute : PropertyAttribute
94{
95    public Type baseType;
96
97    public ImplementsAttribute (Type type)
98    {
99        baseType = type;
100    }
101}
102[Implements(typeof (ITwoFloatOperation))]
103public SerializableType operationType;
104 [CustomPropertyDrawer(typeof(ImplementsAttribute))]
105public class ImplementsDrawer : PropertyDrawer
106{
107    // Return the underlying type of s serialized property
108    private static Type GetType(SerializedProperty property)
109    {
110        // A little bit hacky we first get the type of the object that has this field
111        var parentType = property.serializedObject.targetObject.GetType();
112        // And then once again we use reflection to get the field via it's name again
113        var fi = parentType.GetField(property.propertyPath);
114        return fi.FieldType;
115    }
116
117    private static Type[] FindTypes (Type baseType)
118    {
119        var type = typeof(ITwoFloatOperation);
120        var types = AppDomain.CurrentDomain.GetAssemblies()
121            .SelectMany(s => s.GetTypes())
122            .Where(p => type.IsAssignableFrom(p));
123
124        return types.OrderBy(t => t.AssemblyQualifiedName).ToArray();
125    }
126
127    public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
128    {   
129        label = EditorGUI.BeginProperty(position, label, property);
130
131        var implements = attribute as ImplementsAttribute;
132
133        if (GetType(property) != typeof (SerializableType))
134        {
135            EditorGUI.HelpBox(position, MessageType.Error, "Implements only works for SerializableType!");
136            return;
137        }
138
139        var typeNameProperty = property.FindPropertyRelative("typeName");
140
141        var options = FindTypes (implements.baseType);
142
143        var guiOptions = options.Select(o => o.AssemblyQualifiedName).ToArray();
144
145        var currentType = string.IsNullOrWhiteSpace(typeNameProperty.stringValue) ? null : Type.GetType(typeNameProperty.stringValue);
146
147        var currentIndex = options.FindIndex(o => o == curtentType);
148
149        var newIndex = EditorGUI.Popup(position, label.text, currentIndex, guiOptions);
150
151        var newTypeName = newIndex >= 0 ? options[newIndex] : "";
152       
153        property.stringValue = newTypeName;   
154        EditorGUI.EndProperty();  
155    }
156}
157var instance = (ITwoFloatOperation) Activator.CreateInstance(operationType.Type));
158var result = instance.GetResult(floatA, floatB);
159public abstract class TwoFloatOperation : ScriptableObject
160{
161    public abstract float GetResult(float a, float b);
162}
163

1... snip ...
2
3        // OperatorSelection.GetSelections() is automagically populated by inheritors of the GenericOperation class
4        // So it would represent a collection of types?
5        // so the confusion is primarily around what type this should be
6        public GenericOperations /* ?? */ MathOperations = GenericOperation.GetOperations();
7
8        // this gets assigned by the editor when the user clicks 
9        // the dropdown, but I'm unclear on what the type should
10        // be since it can be one of several types
11        // from the MathOperations collection
12        public Operation /* ?? */ operation;
13        
14        public override object GetValue(NodePort port)
15        {
16            float a = GetInputValue<float>("a", this.a);
17            float b = GetInputValue<float>("b", this.b);
18            result = 0f;
19            result = operation(a, b);
20            return result;
21        }
22
23... snip ...
24
25class GenericOperation:
26
27    @classmethod
28    def get_operations(cls):
29        return cls.__subclasses__()
30
31
32class AddOperation(GenericOperation):
33
34    def __call__(self, a, b):
35        return a + b
36
37
38if __name__ == '__main__':
39    op = AddOperation()
40    res = op(1, 2)
41    print(res)  # 3
42    print(GenericOperation.get_operations())  # {<class '__main__.AddOperation'>}
43
44public interface ITwoFloatOperation
45{
46    public float GetResult(float a, float b);
47}
48public class Add : ITwoFloatOperation
49{
50    public float GetResult(float a, float b) => a + b;
51}
52
53public class Multiply : ITwoFloatOperation
54{
55    public float GetResult(float a, float b) => a * b;
56}
57
58public class Power : ITwoFloatOperation
59{
60    public float GetResult(float a, float b) Mathf.Pow(a, b);
61}
62
63... etc
64using System.Reflection;
65using System.Linq;
66
67...
68
69var type = typeof(ITwoFloatOperation);
70var types = AppDomain.CurrentDomain.GetAssemblies()
71    .SelectMany(s => s.GetTypes())
72    .Where(p => type.IsAssignableFrom(p));
73[Serializable]
74// See https://docs.unity3d.com/ScriptReference/ISerializationCallbackReceiver.html
75public class SerializableType : ISerializationCallbackReceiver
76{
77    private Type type;
78    [SerializeField] private string typeName;
79
80    public Type Type => type;
81
82    public void OnBeforeSerialize()
83    {
84        typeName = type != null ? type.AssemblyQualifiedName : "";
85    }
86
87    public void OnAfterDeserialize()
88    {
89        if(!string.NullOrWhiteSpace(typeName)) type = Type.GetType(typeName);
90    }
91}
92[AttributeUsage(AttributeTarget.Field)]
93public ImplementsAttribute : PropertyAttribute
94{
95    public Type baseType;
96
97    public ImplementsAttribute (Type type)
98    {
99        baseType = type;
100    }
101}
102[Implements(typeof (ITwoFloatOperation))]
103public SerializableType operationType;
104 [CustomPropertyDrawer(typeof(ImplementsAttribute))]
105public class ImplementsDrawer : PropertyDrawer
106{
107    // Return the underlying type of s serialized property
108    private static Type GetType(SerializedProperty property)
109    {
110        // A little bit hacky we first get the type of the object that has this field
111        var parentType = property.serializedObject.targetObject.GetType();
112        // And then once again we use reflection to get the field via it's name again
113        var fi = parentType.GetField(property.propertyPath);
114        return fi.FieldType;
115    }
116
117    private static Type[] FindTypes (Type baseType)
118    {
119        var type = typeof(ITwoFloatOperation);
120        var types = AppDomain.CurrentDomain.GetAssemblies()
121            .SelectMany(s => s.GetTypes())
122            .Where(p => type.IsAssignableFrom(p));
123
124        return types.OrderBy(t => t.AssemblyQualifiedName).ToArray();
125    }
126
127    public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
128    {   
129        label = EditorGUI.BeginProperty(position, label, property);
130
131        var implements = attribute as ImplementsAttribute;
132
133        if (GetType(property) != typeof (SerializableType))
134        {
135            EditorGUI.HelpBox(position, MessageType.Error, "Implements only works for SerializableType!");
136            return;
137        }
138
139        var typeNameProperty = property.FindPropertyRelative("typeName");
140
141        var options = FindTypes (implements.baseType);
142
143        var guiOptions = options.Select(o => o.AssemblyQualifiedName).ToArray();
144
145        var currentType = string.IsNullOrWhiteSpace(typeNameProperty.stringValue) ? null : Type.GetType(typeNameProperty.stringValue);
146
147        var currentIndex = options.FindIndex(o => o == curtentType);
148
149        var newIndex = EditorGUI.Popup(position, label.text, currentIndex, guiOptions);
150
151        var newTypeName = newIndex >= 0 ? options[newIndex] : "";
152       
153        property.stringValue = newTypeName;   
154        EditorGUI.EndProperty();  
155    }
156}
157var instance = (ITwoFloatOperation) Activator.CreateInstance(operationType.Type));
158var result = instance.GetResult(floatA, floatB);
159public abstract class TwoFloatOperation : ScriptableObject
160{
161    public abstract float GetResult(float a, float b);
162}
163[CreateAssetMenu (fileName = "Add", menuName = "TwoFloatOperations/Add")]
164public class Add : TwoFloatOperation
165{
166    public float GetResult(float a, float b) => a + b;
167}
168
169[CreateAssetMenu (fileName = "Multiply", menuName = "TwoFloatOperations/Multiply")]
170public class Multiply : TwoFloatOperation
171{
172    public float GetResult(float a, float b) => a * b;
173}
174
175[CreateAssetMenu (fileName = "Power", menuName = "TwoFloatOperations/Power"]
176public class Power : TwoFloatOperation
177{
178    public float GetResult(float a, float b) Mathf.Pow(a, b);
179}
180

1... snip ...
2
3        // OperatorSelection.GetSelections() is automagically populated by inheritors of the GenericOperation class
4        // So it would represent a collection of types?
5        // so the confusion is primarily around what type this should be
6        public GenericOperations /* ?? */ MathOperations = GenericOperation.GetOperations();
7
8        // this gets assigned by the editor when the user clicks 
9        // the dropdown, but I'm unclear on what the type should
10        // be since it can be one of several types
11        // from the MathOperations collection
12        public Operation /* ?? */ operation;
13        
14        public override object GetValue(NodePort port)
15        {
16            float a = GetInputValue<float>("a", this.a);
17            float b = GetInputValue<float>("b", this.b);
18            result = 0f;
19            result = operation(a, b);
20            return result;
21        }
22
23... snip ...
24
25class GenericOperation:
26
27    @classmethod
28    def get_operations(cls):
29        return cls.__subclasses__()
30
31
32class AddOperation(GenericOperation):
33
34    def __call__(self, a, b):
35        return a + b
36
37
38if __name__ == '__main__':
39    op = AddOperation()
40    res = op(1, 2)
41    print(res)  # 3
42    print(GenericOperation.get_operations())  # {<class '__main__.AddOperation'>}
43
44public interface ITwoFloatOperation
45{
46    public float GetResult(float a, float b);
47}
48public class Add : ITwoFloatOperation
49{
50    public float GetResult(float a, float b) => a + b;
51}
52
53public class Multiply : ITwoFloatOperation
54{
55    public float GetResult(float a, float b) => a * b;
56}
57
58public class Power : ITwoFloatOperation
59{
60    public float GetResult(float a, float b) Mathf.Pow(a, b);
61}
62
63... etc
64using System.Reflection;
65using System.Linq;
66
67...
68
69var type = typeof(ITwoFloatOperation);
70var types = AppDomain.CurrentDomain.GetAssemblies()
71    .SelectMany(s => s.GetTypes())
72    .Where(p => type.IsAssignableFrom(p));
73[Serializable]
74// See https://docs.unity3d.com/ScriptReference/ISerializationCallbackReceiver.html
75public class SerializableType : ISerializationCallbackReceiver
76{
77    private Type type;
78    [SerializeField] private string typeName;
79
80    public Type Type => type;
81
82    public void OnBeforeSerialize()
83    {
84        typeName = type != null ? type.AssemblyQualifiedName : "";
85    }
86
87    public void OnAfterDeserialize()
88    {
89        if(!string.NullOrWhiteSpace(typeName)) type = Type.GetType(typeName);
90    }
91}
92[AttributeUsage(AttributeTarget.Field)]
93public ImplementsAttribute : PropertyAttribute
94{
95    public Type baseType;
96
97    public ImplementsAttribute (Type type)
98    {
99        baseType = type;
100    }
101}
102[Implements(typeof (ITwoFloatOperation))]
103public SerializableType operationType;
104 [CustomPropertyDrawer(typeof(ImplementsAttribute))]
105public class ImplementsDrawer : PropertyDrawer
106{
107    // Return the underlying type of s serialized property
108    private static Type GetType(SerializedProperty property)
109    {
110        // A little bit hacky we first get the type of the object that has this field
111        var parentType = property.serializedObject.targetObject.GetType();
112        // And then once again we use reflection to get the field via it's name again
113        var fi = parentType.GetField(property.propertyPath);
114        return fi.FieldType;
115    }
116
117    private static Type[] FindTypes (Type baseType)
118    {
119        var type = typeof(ITwoFloatOperation);
120        var types = AppDomain.CurrentDomain.GetAssemblies()
121            .SelectMany(s => s.GetTypes())
122            .Where(p => type.IsAssignableFrom(p));
123
124        return types.OrderBy(t => t.AssemblyQualifiedName).ToArray();
125    }
126
127    public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
128    {   
129        label = EditorGUI.BeginProperty(position, label, property);
130
131        var implements = attribute as ImplementsAttribute;
132
133        if (GetType(property) != typeof (SerializableType))
134        {
135            EditorGUI.HelpBox(position, MessageType.Error, "Implements only works for SerializableType!");
136            return;
137        }
138
139        var typeNameProperty = property.FindPropertyRelative("typeName");
140
141        var options = FindTypes (implements.baseType);
142
143        var guiOptions = options.Select(o => o.AssemblyQualifiedName).ToArray();
144
145        var currentType = string.IsNullOrWhiteSpace(typeNameProperty.stringValue) ? null : Type.GetType(typeNameProperty.stringValue);
146
147        var currentIndex = options.FindIndex(o => o == curtentType);
148
149        var newIndex = EditorGUI.Popup(position, label.text, currentIndex, guiOptions);
150
151        var newTypeName = newIndex >= 0 ? options[newIndex] : "";
152       
153        property.stringValue = newTypeName;   
154        EditorGUI.EndProperty();  
155    }
156}
157var instance = (ITwoFloatOperation) Activator.CreateInstance(operationType.Type));
158var result = instance.GetResult(floatA, floatB);
159public abstract class TwoFloatOperation : ScriptableObject
160{
161    public abstract float GetResult(float a, float b);
162}
163[CreateAssetMenu (fileName = "Add", menuName = "TwoFloatOperations/Add")]
164public class Add : TwoFloatOperation
165{
166    public float GetResult(float a, float b) => a + b;
167}
168
169[CreateAssetMenu (fileName = "Multiply", menuName = "TwoFloatOperations/Multiply")]
170public class Multiply : TwoFloatOperation
171{
172    public float GetResult(float a, float b) => a * b;
173}
174
175[CreateAssetMenu (fileName = "Power", menuName = "TwoFloatOperations/Power"]
176public class Power : TwoFloatOperation
177{
178    public float GetResult(float a, float b) Mathf.Pow(a, b);
179}
180public TwoFloatOperation operation;
181

1float freqRange = maxFreq - minFreq;
2float frequency = (x_position_ratio * freqRange) + minFreq;
3// Drawing just note A4 to demonstrate the code
4float a4 = 440.0f //frequency of note A4
5float x_position = (a4 - minFreq) / freqRange;
6minFreq = Mathf.Log10(minFreq);
7maxFreq = Mathf.Log10(maxFreq);
8float freqRange = maxFreq - minFreq;
9x_position = (Mathf.Log10(frequencyOfNoteToPlot) - minFreq) / freqRange;
10

1float freqRange = maxFreq - minFreq;
2float frequency = (x_position_ratio * freqRange) + minFreq;
3// Drawing just note A4 to demonstrate the code
4float a4 = 440.0f //frequency of note A4
5float x_position = (a4 - minFreq) / freqRange;
6minFreq = Mathf.Log10(minFreq);
7maxFreq = Mathf.Log10(maxFreq);
8float freqRange = maxFreq - minFreq;
9x_position = (Mathf.Log10(frequencyOfNoteToPlot) - minFreq) / freqRange;
10frequency = Mathf.Pow(10, x_position * freqRange + minFreq);
11

1library(sf)
2#> Linking to GEOS 3.8.1, GDAL 3.2.1, PROJ 7.2.1
3
4cities <- st_sf(city = "London", geometry = st_sfc(st_point(c(-0.1276, 51.5072))), crs = 4326)
5
6cities
7#> Simple feature collection with 1 feature and 1 field
8#> Geometry type: POINT
9#> Dimension:     XY
10#> Bounding box:  xmin: -0.1276 ymin: 51.5072 xmax: -0.1276 ymax: 51.5072
11#> Geodetic CRS:  WGS 84
12#>     city                geometry
13#> 1 London POINT (-0.1276 51.5072)
14st_crs(cities)
15#> Coordinate Reference System:
16#>   User input: EPSG:4326 
17#>   wkt:
18#> GEOGCRS["WGS 84",
19#>     DATUM["World Geodetic System 1984",
20#>         ELLIPSOID["WGS 84",6378137,298.257223563,
21#>             LENGTHUNIT["metre",1]]],
22#>     PRIMEM["Greenwich",0,
23#>         ANGLEUNIT["degree",0.0174532925199433]],
24#>     CS[ellipsoidal,2],
25#>         AXIS["geodetic latitude (Lat)",north,
26#>             ORDER[1],
27#>             ANGLEUNIT["degree",0.0174532925199433]],
28#>         AXIS["geodetic longitude (Lon)",east,
29#>             ORDER[2],
30#>             ANGLEUNIT["degree",0.0174532925199433]],
31#>     USAGE[
32#>         SCOPE["Horizontal component of 3D system."],
33#>         AREA["World."],
34#>         BBOX[-90,-180,90,180]],
35#>     ID["EPSG",4326]]
36st_crs(st_transform(cities, crs = 32630))
37#> Coordinate Reference System:
38#>   User input: EPSG:32630 
39#>   wkt:
40#> PROJCRS["WGS 84 / UTM zone 30N",
41#>     BASEGEOGCRS["WGS 84",
42#>         DATUM["World Geodetic System 1984",
43#>             ELLIPSOID["WGS 84",6378137,298.257223563,
44#>                 LENGTHUNIT["metre",1]]],
45#>         PRIMEM["Greenwich",0,
46#>             ANGLEUNIT["degree",0.0174532925199433]],
47#>         ID["EPSG",4326]],
48#>     CONVERSION["UTM zone 30N",
49#>         METHOD["Transverse Mercator",
50#>             ID["EPSG",9807]],
51#>         PARAMETER["Latitude of natural origin",0,
52#>             ANGLEUNIT["degree",0.0174532925199433],
53#>             ID["EPSG",8801]],
54#>         PARAMETER["Longitude of natural origin",-3,
55#>             ANGLEUNIT["degree",0.0174532925199433],
56#>             ID["EPSG",8802]],
57#>         PARAMETER["Scale factor at natural origin",0.9996,
58#>             SCALEUNIT["unity",1],
59#>             ID["EPSG",8805]],
60#>         PARAMETER["False easting",500000,
61#>             LENGTHUNIT["metre",1],
62#>             ID["EPSG",8806]],
63#>         PARAMETER["False northing",0,
64#>             LENGTHUNIT["metre",1],
65#>             ID["EPSG",8807]]],
66#>     CS[Cartesian,2],
67#>         AXIS["(E)",east,
68#>             ORDER[1],
69#>             LENGTHUNIT["metre",1]],
70#>         AXIS["(N)",north,
71#>             ORDER[2],
72#>             LENGTHUNIT["metre",1]],
73#>     USAGE[
74#>         SCOPE["Engineering survey, topographic mapping."],
75#>         AREA["Between 6°W and 0°W, northern hemisphere between equator and 84°N, onshore and offshore. Algeria. Burkina Faso. Côte' Ivoire (Ivory Coast). Faroe Islands - offshore. France. Ghana. Gibraltar. Ireland - offshore Irish Sea. Mali. Mauritania. Morocco. Spain. United Kingdom (UK)."],
76#>         BBOX[0,-6,84,0]],
77#>     ID["EPSG",32630]]
78library(sf)
79
80nc_4267 <- read_sf(system.file("shape/nc.shp", package="sf"))
81nc_3857 <- st_transform(nc_4267, 3857)
82
83st_crs(nc_4267, parameters = TRUE)$units_gdal
84#> [1] "degree"
85st_crs(nc_3857, parameters = TRUE)$units_gdal
86#> [1] "metre"
87

1library(sf)
2#> Linking to GEOS 3.8.1, GDAL 3.2.1, PROJ 7.2.1
3
4cities <- st_sf(city = "London", geometry = st_sfc(st_point(c(-0.1276, 51.5072))), crs = 4326)
5
6cities
7#> Simple feature collection with 1 feature and 1 field
8#> Geometry type: POINT
9#> Dimension:     XY
10#> Bounding box:  xmin: -0.1276 ymin: 51.5072 xmax: -0.1276 ymax: 51.5072
11#> Geodetic CRS:  WGS 84
12#>     city                geometry
13#> 1 London POINT (-0.1276 51.5072)
14st_crs(cities)
15#> Coordinate Reference System:
16#>   User input: EPSG:4326 
17#>   wkt:
18#> GEOGCRS["WGS 84",
19#>     DATUM["World Geodetic System 1984",
20#>         ELLIPSOID["WGS 84",6378137,298.257223563,
21#>             LENGTHUNIT["metre",1]]],
22#>     PRIMEM["Greenwich",0,
23#>         ANGLEUNIT["degree",0.0174532925199433]],
24#>     CS[ellipsoidal,2],
25#>         AXIS["geodetic latitude (Lat)",north,
26#>             ORDER[1],
27#>             ANGLEUNIT["degree",0.0174532925199433]],
28#>         AXIS["geodetic longitude (Lon)",east,
29#>             ORDER[2],
30#>             ANGLEUNIT["degree",0.0174532925199433]],
31#>     USAGE[
32#>         SCOPE["Horizontal component of 3D system."],
33#>         AREA["World."],
34#>         BBOX[-90,-180,90,180]],
35#>     ID["EPSG",4326]]
36st_crs(st_transform(cities, crs = 32630))
37#> Coordinate Reference System:
38#>   User input: EPSG:32630 
39#>   wkt:
40#> PROJCRS["WGS 84 / UTM zone 30N",
41#>     BASEGEOGCRS["WGS 84",
42#>         DATUM["World Geodetic System 1984",
43#>             ELLIPSOID["WGS 84",6378137,298.257223563,
44#>                 LENGTHUNIT["metre",1]]],
45#>         PRIMEM["Greenwich",0,
46#>             ANGLEUNIT["degree",0.0174532925199433]],
47#>         ID["EPSG",4326]],
48#>     CONVERSION["UTM zone 30N",
49#>         METHOD["Transverse Mercator",
50#>             ID["EPSG",9807]],
51#>         PARAMETER["Latitude of natural origin",0,
52#>             ANGLEUNIT["degree",0.0174532925199433],
53#>             ID["EPSG",8801]],
54#>         PARAMETER["Longitude of natural origin",-3,
55#>             ANGLEUNIT["degree",0.0174532925199433],
56#>             ID["EPSG",8802]],
57#>         PARAMETER["Scale factor at natural origin",0.9996,
58#>             SCALEUNIT["unity",1],
59#>             ID["EPSG",8805]],
60#>         PARAMETER["False easting",500000,
61#>             LENGTHUNIT["metre",1],
62#>             ID["EPSG",8806]],
63#>         PARAMETER["False northing",0,
64#>             LENGTHUNIT["metre",1],
65#>             ID["EPSG",8807]]],
66#>     CS[Cartesian,2],
67#>         AXIS["(E)",east,
68#>             ORDER[1],
69#>             LENGTHUNIT["metre",1]],
70#>         AXIS["(N)",north,
71#>             ORDER[2],
72#>             LENGTHUNIT["metre",1]],
73#>     USAGE[
74#>         SCOPE["Engineering survey, topographic mapping."],
75#>         AREA["Between 6°W and 0°W, northern hemisphere between equator and 84°N, onshore and offshore. Algeria. Burkina Faso. Côte' Ivoire (Ivory Coast). Faroe Islands - offshore. France. Ghana. Gibraltar. Ireland - offshore Irish Sea. Mali. Mauritania. Morocco. Spain. United Kingdom (UK)."],
76#>         BBOX[0,-6,84,0]],
77#>     ID["EPSG",32630]]
78library(sf)
79
80nc_4267 <- read_sf(system.file("shape/nc.shp", package="sf"))
81nc_3857 <- st_transform(nc_4267, 3857)
82
83st_crs(nc_4267, parameters = TRUE)$units_gdal
84#> [1] "degree"
85st_crs(nc_3857, parameters = TRUE)$units_gdal
86#> [1] "metre"
87st_is_longlat(nc_4267)
88#> [1] TRUE
89st_is_longlat(nc_3857)
90#> [1] FALSE
91