1691 lines
84 KiB
C#
1691 lines
84 KiB
C#
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using UnityEditor;
|
|
|
|
using UnityEngine;
|
|
using UnityEngine.UIElements;
|
|
|
|
namespace NanoBrain {
|
|
|
|
[CustomEditor(typeof(ClusterPrefab))]
|
|
public class ClusterInspector : ClusterViewer {
|
|
public override VisualElement CreateInspectorGUI() {
|
|
ClusterPrefab prefab = target as ClusterPrefab;
|
|
if (prefab != null)
|
|
prefab.EnsureInitialization();
|
|
|
|
serializedObject.Update();
|
|
|
|
VisualElement root = new();
|
|
CreateInspector(root, prefab, prefab.output, null);
|
|
|
|
serializedObject.ApplyModifiedProperties();
|
|
return root;
|
|
}
|
|
|
|
public static GraphView CreateInspector(VisualElement root, ClusterPrefab cluster, Nucleus output, GameObject gameObject) {
|
|
root.style.paddingLeft = 0;
|
|
root.style.paddingRight = 0;
|
|
root.style.paddingTop = 0;
|
|
root.style.paddingBottom = 0;
|
|
|
|
root.styleSheets.Add(Resources.Load<StyleSheet>("GraphStyles"));
|
|
|
|
VisualElement mainContainer = new() {
|
|
style = {
|
|
flexDirection = FlexDirection.Row
|
|
}
|
|
};
|
|
GraphEditor graph = new(cluster);
|
|
graph.style.flexGrow = 1;
|
|
|
|
VisualElement inspectorContainer = new() {
|
|
name = "inspector",
|
|
style = {
|
|
alignSelf = Align.Stretch,
|
|
minHeight = 450,
|
|
width = 300,
|
|
flexGrow = 0
|
|
}
|
|
};
|
|
|
|
mainContainer.Add(graph);
|
|
mainContainer.Add(inspectorContainer);
|
|
root.Add(mainContainer);
|
|
|
|
graph.SetGraph(gameObject, output, inspectorContainer);
|
|
|
|
return graph;
|
|
}
|
|
|
|
public class GraphEditor : GraphView {
|
|
|
|
public GraphEditor(ClusterPrefab prefab) : base(prefab) {
|
|
|
|
|
|
Button addButton = new(() => OnAddClusterOutput()) {
|
|
text = "Add"
|
|
};
|
|
outputContainer.Add(addButton);
|
|
|
|
Add(outputContainer);
|
|
|
|
}
|
|
|
|
void OnAddClusterOutput() {
|
|
Nucleus newOutput = new Neuron(this.prefab, "New Output");
|
|
this.prefab.RefreshOutputs();
|
|
outputsField.choices = this.prefab.outputs.Select(output => output.name).ToList();
|
|
outputsField.value = newOutput.name;
|
|
|
|
this.currentNucleus = newOutput;
|
|
}
|
|
|
|
|
|
public void SetGraph(GameObject gameObject, Nucleus nucleus, VisualElement inspectorContainer) {
|
|
this.gameObject = gameObject;
|
|
//this.cluster = brain;
|
|
if (Application.isPlaying == false)
|
|
this.serializedBrain = new SerializedObject(this.prefab);
|
|
this.currentNucleus = nucleus;
|
|
Rebuild(inspectorContainer);
|
|
}
|
|
|
|
void Rebuild(VisualElement inspectorContainer) {
|
|
BuildLayers();
|
|
|
|
if (this.currentNucleus == null) {
|
|
inspectorContainer.Clear();
|
|
return;
|
|
}
|
|
|
|
string path = AssetDatabase.GetAssetPath(this.prefab); // or known path
|
|
this.prefabAsset = AssetDatabase.LoadAssetAtPath<ClusterPrefab>(path);
|
|
if (this.prefabAsset == null) {
|
|
// create in memory save if it doesn't exist
|
|
this.prefabAsset = CreateInstance<ClusterPrefab>();
|
|
//Debug.LogError("Cluster Prefab is not found on disk");
|
|
}
|
|
DrawInspector(inspectorContainer);
|
|
}
|
|
|
|
#region Inspector
|
|
|
|
private VisualElement inspectorIMGUIContainer;
|
|
private bool showSynapses = true;
|
|
private bool showActivation = true;
|
|
protected bool breakOnWake = false;
|
|
protected bool trace = false;
|
|
void DrawInspector(VisualElement inspectorContainer) {
|
|
if (inspectorContainer == null)
|
|
return;
|
|
|
|
inspectorContainer.Clear();
|
|
if (this.currentNucleus == null)
|
|
return;
|
|
|
|
// create a SerializedObject wrapper so Unity inspector controls work (and Undo)
|
|
SerializedObject so = new(prefabAsset);
|
|
this.inspectorIMGUIContainer = new IMGUIContainer(() => InspectorHandler(so));
|
|
|
|
inspectorContainer.Add(inspectorIMGUIContainer);
|
|
}
|
|
|
|
void InspectorHandler(SerializedObject serializedObject) {
|
|
bool anythingChanged = false;
|
|
|
|
if (serializedObject == null || serializedObject.targetObject == null)
|
|
return;
|
|
|
|
if (this.currentNucleus == null)
|
|
return;
|
|
|
|
serializedObject.Update();
|
|
|
|
GUIStyle headerStyle = new(EditorStyles.boldLabel) {
|
|
alignment = TextAnchor.MiddleLeft,
|
|
margin = new RectOffset(10, 0, 4, 4)
|
|
};
|
|
GUIStyle boldTextFieldStyle = new(EditorStyles.textField) {
|
|
fontStyle = FontStyle.Bold
|
|
};
|
|
|
|
GUILayout.Label(this.currentNucleus.GetType().ToString(), headerStyle);
|
|
string newName = EditorGUILayout.TextField(this.currentNucleus.name, boldTextFieldStyle);
|
|
if (newName != this.currentNucleus.name) {
|
|
this.currentNucleus.name = newName;
|
|
this.prefab.RefreshOutputs();
|
|
outputsField.choices = this.prefab.outputs.Select(output => output.name).ToList();
|
|
anythingChanged = true;
|
|
}
|
|
|
|
if (Application.isPlaying) {
|
|
if (currentNucleus is Neuron currentNeuron1) {
|
|
GUIContent nameLabel = new("Output", currentNeuron1.outputValue.ToString());
|
|
EditorGUILayout.FloatField(nameLabel, currentNeuron1.outputMagnitude);
|
|
}
|
|
else
|
|
EditorGUILayout.LabelField(" ");
|
|
}
|
|
else
|
|
EditorGUILayout.LabelField(" ");
|
|
|
|
if (this.currentNucleus is MemoryCell memory) {
|
|
memory.staticMemory = EditorGUILayout.Toggle("Static Memory", memory.staticMemory);
|
|
}
|
|
|
|
// if (this.currentNucleus is IReceptor receptor1) {
|
|
// EditorGUILayout.BeginHorizontal();
|
|
// EditorGUILayout.IntField("Array size", receptor1.nucleiArray.Count());
|
|
// if (GUILayout.Button("Add")) {
|
|
// Undo.RecordObject(prefabAsset, "Array add " + prefabAsset.name);
|
|
// receptor1.AddReceptorElement(this.prefab);
|
|
// anythingChanged = true;
|
|
// }
|
|
// if (GUILayout.Button("Del")) {
|
|
// Undo.RecordObject(prefabAsset, "Array delete " + prefabAsset.name);
|
|
// receptor1.RemoveReceptorElement();
|
|
// anythingChanged = true;
|
|
// }
|
|
// EditorGUILayout.EndHorizontal();
|
|
|
|
// }
|
|
// else
|
|
if (this.currentNucleus is Cluster cluster) {
|
|
EditorGUILayout.BeginHorizontal();
|
|
if (cluster.siblingClusters != null && cluster.siblingClusters.Length > 1)
|
|
EditorGUILayout.IntField("Array size", cluster.siblingClusters.Count());
|
|
else
|
|
EditorGUILayout.IntField("Array size", 1);
|
|
if (GUILayout.Button("Add")) {
|
|
Undo.RecordObject(prefabAsset, "Array add " + prefabAsset.name);
|
|
cluster.AddInstance(this.prefab);
|
|
anythingChanged = true;
|
|
}
|
|
if (GUILayout.Button("Del")) {
|
|
Undo.RecordObject(prefabAsset, "Array delete " + prefabAsset.name);
|
|
cluster.RemoveInstance();
|
|
anythingChanged = true;
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
}
|
|
|
|
// Synapses
|
|
|
|
//if (this.currentNucleus is not Receptor) { //} && this.currentNucleus is not ClusterReceptor) {
|
|
showSynapses = EditorGUILayout.BeginFoldoutHeaderGroup(showSynapses, "Synapses");
|
|
if (showSynapses) {
|
|
if (this.currentNucleus is Neuron neuron2) {
|
|
Neuron.CombinatorType newCombinator = (Neuron.CombinatorType)EditorGUILayout.EnumPopup("Combinator", neuron2.combinator);
|
|
anythingChanged |= newCombinator != neuron2.combinator;
|
|
neuron2.combinator = newCombinator;
|
|
}
|
|
|
|
EditorGUIUtility.wideMode = true;
|
|
EditorGUIUtility.labelWidth = 100;
|
|
Vector3 newBias = EditorGUILayout.Vector3Field("Bias", this.currentNucleus.bias);
|
|
anythingChanged |= newBias != this.currentNucleus.bias;
|
|
this.currentNucleus.bias = newBias;
|
|
|
|
Nucleus[] array = null;
|
|
int elementIx = -1;
|
|
if (this.currentNucleus.synapses.Count > 0) {
|
|
Synapse[] synapses = this.currentNucleus.synapses.ToArray();
|
|
foreach (Synapse synapse in synapses) {
|
|
if (synapse.neuron == null)
|
|
continue;
|
|
|
|
if (array != null) {
|
|
if (synapse.neuron.parent is Cluster iCluster && elementIx > 0) {
|
|
int thisElementIx = Cluster.GetNucleusIndex(iCluster.clusterNuclei, synapse.neuron);
|
|
if (thisElementIx == elementIx)
|
|
continue;
|
|
else
|
|
elementIx = thisElementIx;
|
|
}
|
|
// if (array.Contains(synapse.nucleus))
|
|
// continue;
|
|
else if (array.Contains(synapse.neuron.parent))
|
|
continue;
|
|
}
|
|
else {
|
|
// if (synapse.neuron.parent is IReceptor iReceptor) {
|
|
// array = iReceptor.nucleiArray;
|
|
// if (iReceptor is Cluster iCluster)
|
|
// elementIx = Cluster.GetNucleusIndex(iCluster.clusterNuclei, synapse.neuron);
|
|
// }
|
|
// else if (synapse.nucleus is Receptor receptor2) // && receptor2.array != null && receptor2.array.nuclei.Length > 1)
|
|
// array = receptor2.nucleiArray;
|
|
}
|
|
|
|
EditorGUILayout.Space();
|
|
|
|
if (Application.isPlaying) {
|
|
if (synapse.neuron is Neuron synapseNeuron) {
|
|
Vector3 value = synapseNeuron.outputValue * synapse.weight;
|
|
GUIContent synapseValueLabel = new(synapse.neuron.name, synapseNeuron.outputValue.ToString());
|
|
EditorGUILayout.FloatField(synapseValueLabel, synapseNeuron.outputMagnitude);
|
|
}
|
|
}
|
|
else {
|
|
EditorGUILayout.BeginHorizontal();
|
|
|
|
if (synapse.neuron.parent != null && synapse.neuron.parent != this.currentNucleus) {
|
|
// If it is a cluster
|
|
GUIStyle labelStyle = new(GUI.skin.label);
|
|
float labelWidth = 200;
|
|
if (synapse.neuron.clusterPrefab != null) {
|
|
labelWidth = labelStyle.CalcSize(new GUIContent($"{synapse.neuron.parent.baseName}.")).x;
|
|
GUILayout.Label($"{synapse.neuron.parent.baseName}", GUILayout.Width(labelWidth));
|
|
}
|
|
string[] options = synapse.neuron.parent.clusterNuclei.Select(n => n.name).ToArray();
|
|
int selectedIndex = System.Array.IndexOf(options, synapse.neuron.name);
|
|
int newIndex = EditorGUILayout.Popup(selectedIndex, options);
|
|
if (newIndex != selectedIndex && synapse.neuron.parent.clusterNuclei[newIndex] is Neuron newNeuron)
|
|
ChangeSynapse(synapse, newNeuron);
|
|
}
|
|
else
|
|
GUILayout.Label(synapse.neuron.name);
|
|
|
|
bool disconnecting = GUILayout.Button("Disconnect", GUILayout.Width(80));
|
|
if (disconnecting && synapse.neuron is Neuron synapseNeuron) {
|
|
synapseNeuron.RemoveReceiver(this.currentNucleus);
|
|
this.prefab.GarbageCollection();
|
|
anythingChanged = true;
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
|
|
}
|
|
|
|
EditorGUI.indentLevel++;
|
|
float newWeight = EditorGUILayout.FloatField("Weight", synapse.weight);
|
|
if (newWeight != synapse.weight) {
|
|
// if (synapse.neuron.parent is IReceptor receptor) {
|
|
// Nucleus[] receptorArray = receptor.nucleiArray;
|
|
// foreach (Synapse s in this.currentNucleus.synapses) {
|
|
// if (s.neuron.parent is IReceptor r && r.nucleiArray == receptorArray)
|
|
// s.weight = newWeight;
|
|
// }
|
|
// }
|
|
// else
|
|
synapse.weight = newWeight;
|
|
anythingChanged = true;
|
|
}
|
|
EditorGUI.indentLevel--;
|
|
}
|
|
}
|
|
|
|
EditorGUILayout.Space();
|
|
anythingChanged |= ConnectNucleus(this.prefab, this.currentNucleus);
|
|
anythingChanged |= AddSynapse(this.prefab, this.currentNucleus);
|
|
}
|
|
EditorGUILayout.EndFoldoutHeaderGroup();
|
|
//}
|
|
|
|
// Activation
|
|
|
|
if (this.currentNucleus is not Cluster) {
|
|
EditorGUILayout.Space();
|
|
showActivation = EditorGUILayout.BeginFoldoutHeaderGroup(showActivation, "Activation");
|
|
if (showActivation) {
|
|
if (this.currentNucleus is Neuron neuron) {
|
|
if (this.currentNucleus is not MemoryCell) {
|
|
EditorGUILayout.BeginHorizontal();
|
|
EditorGUILayout.LabelField("Activation Curve", GUILayout.Width(150));
|
|
if (neuron.curveMax > 0)
|
|
EditorGUILayout.CurveField(neuron.curve, Color.cyan, new Rect(0, 0, 1, neuron.curveMax));
|
|
else
|
|
EditorGUILayout.CurveField(neuron.curve, Color.cyan, new Rect(0, neuron.curveMax, 1, -neuron.curveMax));
|
|
Neuron.ActivationType newPreset = (Neuron.ActivationType)EditorGUILayout.EnumPopup(neuron.curvePreset, GUILayout.Width(100));
|
|
anythingChanged |= newPreset != neuron.curvePreset;
|
|
neuron.curvePreset = newPreset;
|
|
EditorGUILayout.EndHorizontal();
|
|
}
|
|
// if (neuron is Receptor receptor2) {
|
|
// if (receptor2.nucleiArray == null || receptor2.nucleiArray.Count() == 0)
|
|
// receptor2.array = new NucleusArray(neuron);
|
|
// }
|
|
}
|
|
|
|
EditorGUILayout.Space();
|
|
}
|
|
EditorGUILayout.EndFoldoutHeaderGroup();
|
|
}
|
|
|
|
if (GUILayout.Button("Delete this neuron"))
|
|
DeleteNucleus(this.currentNucleus);
|
|
|
|
if (this.currentNucleus is Cluster subCluster) {
|
|
if (GUILayout.Button("Edit Cluster"))
|
|
EditCluster(subCluster);
|
|
}
|
|
|
|
EditorGUILayout.Space();
|
|
breakOnWake = EditorGUILayout.Toggle("Break on wake", breakOnWake);
|
|
if (breakOnWake && this.currentNucleus is Neuron currentNeuron) {
|
|
if (currentNeuron.isSleeping == false)
|
|
Debug.Break();
|
|
}
|
|
trace = EditorGUILayout.Toggle("Trace", trace);
|
|
this.currentNucleus.trace = trace;
|
|
|
|
serializedObject.ApplyModifiedProperties();
|
|
if (anythingChanged) {
|
|
EditorUtility.SetDirty(prefabAsset);
|
|
AssetDatabase.SaveAssets();
|
|
}
|
|
}
|
|
|
|
void OnSceneGUI(SceneView sceneView) {
|
|
if (this.gameObject != null) {
|
|
// if (this.currentNucleus is IReceptor receptor) {
|
|
// foreach (Nucleus nucleus in receptor.nucleiArray) {
|
|
// if (nucleus is Neuron neuron) {
|
|
// Vector3 worldVector = this.gameObject.transform.TransformVector(neuron.outputValue);
|
|
// Handles.color = Color.yellow;
|
|
// Handles.DrawLine(this.gameObject.transform.position, this.gameObject.transform.position + worldVector);
|
|
// }
|
|
// }
|
|
// }
|
|
// else {
|
|
if (this.currentNucleus is Neuron currentNeuron) {
|
|
Vector3 worldVector = this.gameObject.transform.TransformVector(currentNeuron.outputValue);
|
|
Handles.color = Color.yellow;
|
|
Handles.DrawLine(this.gameObject.transform.position, this.gameObject.transform.position + worldVector);
|
|
}
|
|
// }
|
|
}
|
|
}
|
|
|
|
#region Synapses
|
|
|
|
protected virtual void AddInput(Nucleus.Type selectedType, Nucleus nucleus) {
|
|
switch (selectedType) {
|
|
case Nucleus.Type.Neuron:
|
|
AddNeuronInput(nucleus);
|
|
break;
|
|
case Nucleus.Type.MemoryCell:
|
|
AddMemoryCellInput(nucleus);
|
|
break;
|
|
case Nucleus.Type.Cluster:
|
|
AddClusterInput(nucleus);
|
|
break;
|
|
// case Nucleus.Type.Receptor:
|
|
// AddReceptorInput(nucleus);
|
|
// break;
|
|
// case Nucleus.Type.ClusterReceptor:
|
|
// AddClusterReceptorInput(nucleus);
|
|
// break;
|
|
// case Nucleus.Type.ClusterArray:
|
|
// AddClusterArrayInput(nucleus);
|
|
// break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
protected virtual void AddNeuronInput(Nucleus nucleus) {
|
|
Neuron newNeuroid = new(this.prefab, "New neuron");
|
|
newNeuroid.AddReceiver(nucleus);
|
|
this.currentNucleus = newNeuroid;
|
|
BuildLayers();
|
|
}
|
|
|
|
protected virtual void AddMemoryCellInput(Nucleus nucleus) {
|
|
MemoryCell newMemory = new(this.prefab, "New memory cell");
|
|
newMemory.AddReceiver(nucleus);
|
|
this.currentNucleus = newMemory;
|
|
BuildLayers();
|
|
}
|
|
|
|
protected virtual void AddClusterInput(Nucleus nucleus) {
|
|
ClusterPickerWindow.ShowPicker(brain => OnClusterPicked(nucleus, brain), "Select Cluster");
|
|
}
|
|
private void OnClusterPicked(Nucleus nucleus, ClusterPrefab prefab) {
|
|
Cluster subclusterInstance = new(prefab, this.prefab);
|
|
subclusterInstance.defaultOutput.AddReceiver(nucleus);
|
|
}
|
|
|
|
// protected virtual void AddReceptorInput(Nucleus nucleus) {
|
|
// Receptor newReceptor = new(this.prefab, "New Receptor");
|
|
// newReceptor.AddReceiver(nucleus);
|
|
// this.currentNucleus = newReceptor;
|
|
// BuildLayers();
|
|
// }
|
|
|
|
// protected virtual void AddClusterReceptorInput(Nucleus nucleus) {
|
|
// ClusterPickerWindow.ShowPicker(prefab => OnClusterReceptorPicked(nucleus, prefab), "Select Cluster");
|
|
// }
|
|
// private void OnClusterReceptorPicked(Nucleus nucleus, ClusterPrefab selectedPrefab) {
|
|
// ClusterReceptor clusterInstance = new(selectedPrefab, this.prefab, "New " + selectedPrefab.name);
|
|
// clusterInstance.defaultOutput.AddReceiver(nucleus);
|
|
// this.currentNucleus = clusterInstance;
|
|
// BuildLayers();
|
|
// }
|
|
|
|
private void EditCluster(Cluster subCluster) {
|
|
// May be used with storedPrefab...
|
|
Selection.activeObject = subCluster.prefab;
|
|
EditorGUIUtility.PingObject(subCluster.prefab);
|
|
var editor = Editor.CreateEditor(subCluster.prefab);
|
|
}
|
|
|
|
// protected virtual void AddClusterArrayInput(Nucleus nucleus) {
|
|
// ClusterPickerWindow.ShowPicker(prefab => OnPickedClusterArray(nucleus, prefab), "Select Cluster");
|
|
// }
|
|
// private void OnPickedClusterArray(Nucleus nucleus, ClusterPrefab selectedPrefab) {
|
|
// _ = new ClusterArray(selectedPrefab, this.prefab, 1, nucleus);
|
|
// }
|
|
|
|
int selectedConnectNucleus = -1;
|
|
// Connect to another nucleus in the same cluster
|
|
protected virtual bool ConnectNucleus(ClusterPrefab cluster, Nucleus nucleusToConnect) {
|
|
if (cluster == null)
|
|
return false;
|
|
|
|
IEnumerable<Nucleus> synapseNuclei = this.currentNucleus.synapses
|
|
.Where(synapse => synapse.neuron != null)
|
|
.Select(synapse => synapse.neuron);
|
|
|
|
IEnumerable<Nucleus> nuclei = cluster.nuclei
|
|
.Except(synapseNuclei);
|
|
IEnumerable<string> nucleiNames = nuclei
|
|
.Select(n => {
|
|
int idx = n.name.IndexOf(':');
|
|
return idx < 0 ? n.name : n.name[..idx];
|
|
})
|
|
.Distinct();
|
|
|
|
string[] names = nucleiNames.ToArray();
|
|
EditorGUILayout.BeginHorizontal();
|
|
selectedConnectNucleus = EditorGUILayout.Popup(selectedConnectNucleus, names);
|
|
bool connecting = GUILayout.Button("Connect", GUILayout.Width(80));
|
|
EditorGUILayout.EndHorizontal();
|
|
if (connecting) {
|
|
Nucleus nucleus = nuclei.ElementAt(selectedConnectNucleus);
|
|
// if (nucleus is IReceptor receptor)
|
|
// receptor.AddArrayReceiver(this.currentNucleus);
|
|
// else
|
|
if (nucleus is Neuron neuron)
|
|
neuron.AddReceiver(this.currentNucleus);
|
|
else if (nucleus is Cluster subCluster)
|
|
subCluster.defaultOutput.AddReceiver(this.currentNucleus);
|
|
|
|
}
|
|
return connecting;
|
|
}
|
|
|
|
protected virtual void DeleteNucleus(Nucleus nucleus) {
|
|
if (nucleus == null)
|
|
return;
|
|
|
|
if (nucleus is Neuron neuron) {
|
|
foreach (Nucleus receiver in neuron.receivers) {
|
|
if (receiver != null) {
|
|
this.currentNucleus = receiver;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
this.prefab.nuclei.Remove(nucleus);
|
|
|
|
if (outputsField.value == nucleus.name) {
|
|
this.prefab.RefreshOutputs();
|
|
outputsField.choices = this.prefab.outputs.Select(output => output.name).ToList();
|
|
outputsField.index = 0;
|
|
}
|
|
|
|
Neuron.Delete(nucleus);
|
|
|
|
this.currentNucleus = this.prefab.output;
|
|
BuildLayers();
|
|
}
|
|
|
|
Nucleus.Type selectedType = Nucleus.Type.None;
|
|
protected virtual bool AddSynapse(ClusterPrefab cluster, Nucleus nucleus) {
|
|
if (cluster == null)
|
|
return false;
|
|
|
|
EditorGUILayout.BeginHorizontal();
|
|
selectedType = (Nucleus.Type)EditorGUILayout.EnumPopup(selectedType);
|
|
bool connecting = GUILayout.Button("Add", GUILayout.Width(80));
|
|
EditorGUILayout.EndHorizontal();
|
|
|
|
if (connecting) {
|
|
AddInput(selectedType, this.currentNucleus);
|
|
}
|
|
return connecting;
|
|
// if (selectedType == Nucleus.Type.None)
|
|
// return false;
|
|
|
|
// AddInput(selectedType, this.currentNucleus);
|
|
// return true;
|
|
}
|
|
|
|
protected virtual void ChangeSynapse(Synapse synapse, Neuron newNucleus) {
|
|
Neuron synapseNeuron = synapse.neuron as Neuron;
|
|
if (synapse.neuron.parent is Cluster subCluster && subCluster.prefab != this.prefab) {
|
|
// if (synapse.neuron.parent is ClusterReceptor receptor) {
|
|
// // the new nucleus is part of a (cluster) receptor,
|
|
// // so we have to change all synapses to this nucleus array elements
|
|
// int oldNucleusIx = Cluster.GetNucleusIndex(subCluster.clusterNuclei, synapse.neuron);
|
|
// int newNucleusIx = Cluster.GetNucleusIndex(subCluster.clusterNuclei, newNucleus);
|
|
// foreach (Nucleus element in receptor.nucleiArray) {
|
|
// if (element is not ClusterReceptor clusterReceptor)
|
|
// continue;
|
|
// // Get the same neuron as the synapse.nucleus in a different element
|
|
// // of the ClusterReceptor array
|
|
// Nucleus oldElementNucleus = clusterReceptor.clusterNuclei[oldNucleusIx];
|
|
// if (oldElementNucleus is not Neuron oldElementNeuron)
|
|
// continue;
|
|
// // Get the same neuron as newNucleus in a different element
|
|
// // of the ClusterReceptor array
|
|
// Nucleus newElementNucleus = clusterReceptor.clusterNuclei[newNucleusIx];
|
|
// if (newElementNucleus is not Neuron newElementNeuron)
|
|
// continue;
|
|
|
|
// oldElementNeuron.RemoveReceiver(this.currentNucleus);
|
|
// newElementNeuron.AddReceiver(this.currentNucleus);
|
|
// // Now find the synapse which pointed to the old Neuron
|
|
// // Synapse synapseForUpdate = this.currentNucleus.GetSynapse(oldElementNeuron);
|
|
// // synapseForUpdate.nucleus = newElementNeuron;
|
|
// }
|
|
// }
|
|
// else {
|
|
// it is a neuron in a subcluster
|
|
synapseNeuron.RemoveReceiver(this.currentNucleus);
|
|
newNucleus.AddReceiver(this.currentNucleus);
|
|
// }
|
|
}
|
|
else {
|
|
synapseNeuron.RemoveReceiver(this.currentNucleus);
|
|
newNucleus.AddReceiver(this.currentNucleus);
|
|
}
|
|
}
|
|
|
|
protected virtual void DisconnectNucleus(Neuron nucleus) {
|
|
if (this.currentNucleus.clusterPrefab == null)
|
|
return;
|
|
string[] names = this.currentNucleus.synapses.Select(synapse => synapse.neuron.name).ToArray();
|
|
int selectedIndex = -1;
|
|
selectedIndex = EditorGUILayout.Popup("Disconnect from", selectedIndex, names);
|
|
if (selectedIndex >= 0 && selectedIndex < this.currentNucleus.clusterPrefab.nuclei.Count) {
|
|
Synapse synapse = this.currentNucleus.synapses[selectedIndex];
|
|
Neuron synapseNeuron = synapse.neuron as Neuron;
|
|
synapseNeuron.RemoveReceiver(this.currentNucleus);
|
|
}
|
|
}
|
|
|
|
#endregion Synapses
|
|
|
|
#endregion Inspector
|
|
}
|
|
}
|
|
/*
|
|
[CustomEditor(typeof(ClusterPrefab))]
|
|
public class ClusterInspector : Editor {
|
|
|
|
public override VisualElement CreateInspectorGUI() {
|
|
ClusterPrefab prefab = target as ClusterPrefab;
|
|
if (prefab != null)
|
|
prefab.EnsureInitialization();
|
|
|
|
serializedObject.Update();
|
|
|
|
VisualElement root = new();
|
|
CreateInspector(root, prefab, prefab.output, null);
|
|
|
|
serializedObject.ApplyModifiedProperties();
|
|
return root;
|
|
}
|
|
|
|
public static GraphView CreateInspector(VisualElement root, ClusterPrefab cluster, Nucleus output, GameObject gameObject) {
|
|
root.style.paddingLeft = 0;
|
|
root.style.paddingRight = 0;
|
|
root.style.paddingTop = 0;
|
|
root.style.paddingBottom = 0;
|
|
|
|
root.styleSheets.Add(Resources.Load<StyleSheet>("GraphStyles"));
|
|
|
|
VisualElement mainContainer = new() {
|
|
style = {
|
|
flexDirection = FlexDirection.Row
|
|
}
|
|
};
|
|
GraphView graph = new(cluster);
|
|
graph.style.flexGrow = 1;
|
|
|
|
VisualElement inspectorContainer = new VisualElement {
|
|
name = "inspector",
|
|
style = {
|
|
alignSelf = Align.Stretch,
|
|
minHeight = 450,
|
|
width = 300,
|
|
flexGrow = 0
|
|
}
|
|
};
|
|
|
|
mainContainer.Add(graph);
|
|
mainContainer.Add(inspectorContainer);
|
|
root.Add(mainContainer);
|
|
|
|
graph.SetGraph(gameObject, output, inspectorContainer);
|
|
|
|
return graph;
|
|
}
|
|
|
|
public class GraphView : VisualElement {
|
|
readonly ClusterPrefab prefab;
|
|
SerializedObject serializedBrain;
|
|
Nucleus currentNucleus;
|
|
GameObject gameObject;
|
|
private List<NeuroidLayer> layers = new();
|
|
private readonly Dictionary<Nucleus, Vector2Int> neuroidPositions = new();
|
|
private bool expandArray = false;
|
|
|
|
ClusterPrefab prefabAsset;
|
|
readonly PopupField<string> outputsField;
|
|
|
|
public GraphView(ClusterPrefab prefab) {
|
|
this.prefab = prefab;
|
|
|
|
name = "content";
|
|
style.flexGrow = 1;
|
|
|
|
IMGUIContainer graphContainer = new(OnIMGUI);
|
|
graphContainer.style.position = Position.Absolute;
|
|
graphContainer.style.left = 0; graphContainer.style.top = 0;
|
|
graphContainer.style.right = 0; graphContainer.style.bottom = 0;
|
|
graphContainer.pickingMode = PickingMode.Position;
|
|
graphContainer.focusable = true;
|
|
Add(graphContainer);
|
|
|
|
VisualElement outputContainer = new() {
|
|
style = {
|
|
flexDirection = FlexDirection.Row,
|
|
alignItems = Align.Center,
|
|
}
|
|
};
|
|
|
|
List<string> names = this.prefab.outputs.Select(output => output.name).ToList();
|
|
if (names.Count > 0 && names.First() != null) {
|
|
outputsField = new(names, names.First()) {
|
|
style = { flexGrow = 1 }
|
|
};
|
|
outputsField.RegisterValueChangedCallback(evt => OnOutputChanged(evt.newValue));
|
|
outputContainer.Add(outputsField);
|
|
}
|
|
|
|
Button addButton = new(() => OnAddClusterOutput()) {
|
|
text = "Add"
|
|
};
|
|
outputContainer.Add(addButton);
|
|
|
|
Add(outputContainer);
|
|
|
|
// Subscribe when added to panel (editor UI ready)
|
|
RegisterCallback<AttachToPanelEvent>(evt => Subscribe());
|
|
RegisterCallback<DetachFromPanelEvent>(evt => Unsubscribe());
|
|
}
|
|
|
|
void OnOutputChanged(string outputName) {
|
|
if (this.currentNucleus.parent != null)
|
|
// Get nucleus in the parent instance
|
|
this.currentNucleus = this.currentNucleus.parent.GetNucleus(outputName);
|
|
else
|
|
// Get nucleus in the prefab
|
|
this.currentNucleus = this.prefab.GetNucleus(outputName);
|
|
}
|
|
|
|
void OnAddClusterOutput() {
|
|
Nucleus newOutput = new Neuron(this.prefab, "New Output");
|
|
this.prefab.RefreshOutputs();
|
|
outputsField.choices = this.prefab.outputs.Select(output => output.name).ToList();
|
|
outputsField.value = newOutput.name;
|
|
|
|
this.currentNucleus = newOutput;
|
|
}
|
|
|
|
bool subscribed = false;
|
|
void Subscribe() {
|
|
if (subscribed) return;
|
|
SceneView.duringSceneGui += OnSceneGUI;
|
|
subscribed = true;
|
|
SceneView.RepaintAll();
|
|
}
|
|
|
|
void Unsubscribe() {
|
|
if (!subscribed) return;
|
|
SceneView.duringSceneGui -= OnSceneGUI;
|
|
subscribed = false;
|
|
}
|
|
|
|
public void SetGraph(GameObject gameObject, Nucleus nucleus, VisualElement inspectorContainer) {
|
|
this.gameObject = gameObject;
|
|
//this.cluster = brain;
|
|
if (Application.isPlaying == false)
|
|
this.serializedBrain = new SerializedObject(this.prefab);
|
|
this.currentNucleus = nucleus;
|
|
Rebuild(inspectorContainer);
|
|
}
|
|
|
|
void Rebuild(VisualElement inspectorContainer) {
|
|
BuildLayers();
|
|
|
|
if (this.currentNucleus == null) {
|
|
inspectorContainer.Clear();
|
|
return;
|
|
}
|
|
|
|
string path = AssetDatabase.GetAssetPath(this.prefab); // or known path
|
|
this.prefabAsset = AssetDatabase.LoadAssetAtPath<ClusterPrefab>(path);
|
|
if (this.prefabAsset == null) {
|
|
// create in memory save if it doesn't exist
|
|
this.prefabAsset = CreateInstance<ClusterPrefab>();
|
|
//Debug.LogError("Cluster Prefab is not found on disk");
|
|
}
|
|
DrawInspector(inspectorContainer);
|
|
}
|
|
|
|
private void BuildLayers() {
|
|
// A temporary list to track what's been added to layers
|
|
this.layers = new();
|
|
int layerIx = 0;
|
|
|
|
Nucleus selectedNucleus = this.currentNucleus;
|
|
if (selectedNucleus == null)
|
|
return;
|
|
NeuroidLayer currentLayer = new() { ix = layerIx };
|
|
|
|
if (selectedNucleus is Neuron selectedNeuron && selectedNeuron.receivers != null) {
|
|
foreach (Nucleus receiver in selectedNeuron.receivers) {
|
|
Nucleus outputNeuroid = receiver;
|
|
if (outputNeuroid != null) {
|
|
AddToLayer(currentLayer, outputNeuroid);
|
|
// Debug.Log($"layer {layerIx} nucleus {outputNeuroid.name}");
|
|
}
|
|
}
|
|
}
|
|
if (currentLayer.neuroids.Count > 0) {
|
|
this.layers.Add(currentLayer);
|
|
layerIx++;
|
|
currentLayer = new() { ix = layerIx };
|
|
}
|
|
|
|
AddToLayer(currentLayer, selectedNucleus);
|
|
this.layers.Add(currentLayer);
|
|
// Debug.Log($"layer {layerIx} nucleus {selectedNucleus.name}");
|
|
|
|
layerIx++;
|
|
currentLayer = new() { ix = layerIx };
|
|
|
|
if (selectedNucleus.synapses != null) {
|
|
foreach (Synapse synapse in selectedNucleus.synapses) {
|
|
Nucleus input = synapse.neuron;
|
|
AddToLayer(currentLayer, input);
|
|
// Debug.Log($"layer {layerIx} nucleus {input.name}");
|
|
}
|
|
}
|
|
if (currentLayer.neuroids.Count > 0) {
|
|
this.layers.Add(currentLayer);
|
|
}
|
|
}
|
|
|
|
private void AddToLayer(NeuroidLayer layer, Nucleus nucleus) {
|
|
if (nucleus == null)
|
|
return;
|
|
layer.neuroids.Add(nucleus);
|
|
//nucleus.layerIx = layer.ix;
|
|
// Store its position
|
|
Vector2Int neuroidPosition = new(layer.ix, layer.neuroids.Count - 1);
|
|
neuroidPositions[nucleus] = neuroidPosition;
|
|
|
|
}
|
|
|
|
public void OnIMGUI() {
|
|
if (currentNucleus == null)
|
|
return;
|
|
|
|
if (Application.isPlaying == false)
|
|
serializedBrain.Update();
|
|
|
|
Handles.BeginGUI();
|
|
DrawGraph();
|
|
Handles.EndGUI();
|
|
|
|
}
|
|
|
|
private void DrawGraph() {
|
|
float size = 20;
|
|
Vector3 position = new(150, 210, 0);
|
|
|
|
DrawReceivers(this.currentNucleus, position, size);
|
|
DrawSynapses(this.currentNucleus, position, size);
|
|
|
|
// Draw selected Nucleus
|
|
if (expandArray) {
|
|
if (this.currentNucleus is IReceptor receptor1) {
|
|
float maxValue = 0;
|
|
foreach (Nucleus nucleus in receptor1.nucleiArray) {
|
|
if (nucleus is Neuron neuron) {
|
|
float value = neuron.outputMagnitude;
|
|
if (value > maxValue)
|
|
maxValue = value;
|
|
}
|
|
}
|
|
|
|
float spacing = 400f / receptor1.nucleiArray.Count();
|
|
float margin = 10 + spacing / 2;
|
|
float xMin = 150 - size;
|
|
float xMax = 150 + size;
|
|
float yMin = 10 + margin - size / 2;
|
|
float yMax = 400 - margin + size;
|
|
Vector3[] verts = new Vector3[4] {
|
|
new(xMin, yMin, 0),
|
|
new(xMax, yMin, 0),
|
|
new(xMax, yMax, 0),
|
|
new(xMin, yMax, 0)
|
|
};
|
|
Handles.color = Color.black;
|
|
Handles.DrawAAConvexPolygon(verts);
|
|
int row = 0;
|
|
foreach (Nucleus nucleus in receptor1.nucleiArray) {
|
|
Vector3 pos = new(150, margin + row * spacing, 0.0f);
|
|
Handles.color = Color.white;
|
|
// The selected nucleus highlight ring
|
|
Handles.DrawSolidDisc(pos, Vector3.forward, size + 2);
|
|
DrawNucleus(nucleus, pos, maxValue, size);
|
|
row++;
|
|
}
|
|
GUIStyle style = new(EditorStyles.label) {
|
|
alignment = TextAnchor.UpperCenter,
|
|
normal = { textColor = Color.white },
|
|
fontStyle = FontStyle.Bold,
|
|
};
|
|
Vector3 labelPos = new(150, yMax + size + 5, 0);
|
|
string receptorName = receptor1.GetName();
|
|
int colonPos = receptorName.IndexOf(":");
|
|
if (colonPos > 0) {
|
|
string baseName = receptorName[..colonPos];
|
|
Handles.Label(labelPos, baseName, style);
|
|
}
|
|
else
|
|
Handles.Label(labelPos, receptorName, style);
|
|
}
|
|
else {
|
|
Handles.color = Color.white;
|
|
// The selected nucleus highlight ring
|
|
Handles.DrawSolidDisc(position, Vector3.forward, size + 2);
|
|
float maxValue = 1;
|
|
if (this.currentNucleus is Neuron neuron)
|
|
maxValue = neuron.outputMagnitude;
|
|
else if (this.currentNucleus is Cluster cluster)
|
|
maxValue = cluster.defaultOutput.outputMagnitude;
|
|
|
|
DrawNucleus(this.currentNucleus, position, maxValue, 20);
|
|
|
|
}
|
|
}
|
|
else {
|
|
Handles.color = Color.white;
|
|
// The selected nucleus highlight ring
|
|
Handles.DrawSolidDisc(position, Vector3.forward, size + 2);
|
|
float maxValue = 1;
|
|
if (this.currentNucleus is Neuron neuron)
|
|
maxValue = neuron.outputMagnitude;
|
|
else if (this.currentNucleus is Cluster cluster)
|
|
maxValue = cluster.defaultOutput.outputMagnitude;
|
|
DrawNucleus(this.currentNucleus, position, maxValue, 20);
|
|
}
|
|
}
|
|
|
|
private void DrawReceivers(Nucleus nucleus, Vector3 parentPos, float size) {
|
|
List<Nucleus> receivers;
|
|
if (nucleus is Neuron neuron)
|
|
receivers = neuron.receivers;
|
|
else if (nucleus is Cluster cluster)
|
|
receivers = cluster.CollectReceivers();
|
|
else
|
|
return;
|
|
|
|
int nodeCount = receivers.Count(); //neuron != null ? neuron.receivers.Count() : 1;
|
|
|
|
// Determine the maximum value in this layer
|
|
// This is used to 'scale' the output value colors of the nuclei
|
|
float maxValue = 0;
|
|
foreach (Nucleus receiver in receivers) {
|
|
if (receiver is Neuron neuroid) {
|
|
float value = neuroid.outputMagnitude;
|
|
if (value > maxValue)
|
|
maxValue = value;
|
|
}
|
|
}
|
|
|
|
// Determine the spacing of the nuclei in the layer
|
|
float spacing = 400f / nodeCount;
|
|
float margin = 10 + spacing / 2;
|
|
|
|
int row = 0;
|
|
List<Nucleus[]> drawnArrays = new();
|
|
foreach (Nucleus receiver in receivers) {
|
|
if (receiver is Receptor receptor) {
|
|
if (drawnArrays.Contains(receptor.nucleiArray))
|
|
continue;
|
|
drawnArrays.Add(receptor.nucleiArray);
|
|
}
|
|
|
|
Nucleus receiverNucleus = receiver;
|
|
if (receiverNucleus == null)
|
|
continue;
|
|
|
|
Vector3 pos = new(50, margin + row * spacing, 0.0f);
|
|
Handles.color = Color.white;
|
|
Handles.DrawLine(parentPos, pos);
|
|
|
|
DrawNucleus(receiverNucleus, pos, maxValue, size);
|
|
row++;
|
|
}
|
|
}
|
|
|
|
private void DrawSynapses(Nucleus nucleus, Vector3 parentPos, float size) {
|
|
int nodeCount = nucleus.synapses.Count;
|
|
|
|
// Determine the maximum value in this layer
|
|
// This is used to 'scale' the output value colors of the nuclei
|
|
float maxValue = 0;
|
|
int neuronCount = 0;
|
|
List<Nucleus[]> drawnArrays = new();
|
|
foreach (Synapse synapse in nucleus.synapses) {
|
|
if (synapse.neuron == null)
|
|
continue;
|
|
|
|
if (synapse.neuron is Receptor receptor) {
|
|
if (drawnArrays.Contains(receptor.nucleiArray))
|
|
continue;
|
|
drawnArrays.Add(receptor.nucleiArray);
|
|
}
|
|
else if (synapse.neuron.parent is ClusterReceptor clusterReceptor) {
|
|
if (drawnArrays.Contains(clusterReceptor.nucleiArray))
|
|
continue;
|
|
drawnArrays.Add(clusterReceptor.nucleiArray);
|
|
}
|
|
if (synapse.neuron is Neuron synapseNeuron) {
|
|
float value = synapseNeuron.outputMagnitude * synapse.weight;
|
|
// Debug.Log($"{synapse.nucleus.name}: {value} {length(synapse.nucleus.outputValue)} {synapse.weight}");
|
|
if (value > maxValue)
|
|
maxValue = value;
|
|
}
|
|
neuronCount++;
|
|
}
|
|
|
|
// Determine the spacing of the nuclei in the layer
|
|
float spacing = 400f / neuronCount;
|
|
float margin = 10 + spacing / 2;
|
|
|
|
int row = 0;
|
|
drawnArrays = new();
|
|
foreach (Synapse synapse in nucleus.synapses) {
|
|
if (synapse.neuron is null)
|
|
continue;
|
|
|
|
if (synapse.neuron is Receptor neuron) {
|
|
if (drawnArrays.Contains(neuron.nucleiArray))
|
|
continue;
|
|
drawnArrays.Add(neuron.nucleiArray);
|
|
}
|
|
else if (synapse.neuron.parent is ClusterReceptor clusterReceptor) {
|
|
if (drawnArrays.Contains(clusterReceptor.nucleiArray))
|
|
continue;
|
|
drawnArrays.Add(clusterReceptor.nucleiArray);
|
|
}
|
|
Vector3 pos = new(250, margin + row * spacing, 0.0f);
|
|
Handles.color = Color.white;
|
|
Handles.DrawLine(parentPos, pos);
|
|
Color color = Color.black;
|
|
if (Application.isPlaying) {
|
|
if (maxValue == 0 || !float.IsFinite(maxValue))
|
|
maxValue = 1;
|
|
float brightness = 0;
|
|
if (synapse.neuron is Neuron synapseNeuron)
|
|
brightness = synapseNeuron.outputMagnitude * synapse.weight / maxValue;
|
|
color = new Color(brightness, brightness, brightness, 1f);
|
|
}
|
|
if (synapse.neuron.parent != null && synapse.neuron.parent != this.currentNucleus.parent) {
|
|
// the synapse nucleus is part of a subcluster
|
|
DrawNucleus(synapse.neuron.parent, pos, maxValue, size, color);
|
|
}
|
|
// else if (synapse.nucleus.cluster != null && synapse.nucleus.cluster != this.currentNucleus.cluster) {
|
|
// DrawNucleus(synapse.nucleus.parent, pos, maxValue, size, color);
|
|
// }
|
|
else {
|
|
DrawNucleus(synapse.neuron, pos, maxValue, size, color);
|
|
}
|
|
row++;
|
|
}
|
|
}
|
|
|
|
private void DrawNucleus(Nucleus nucleus, Vector3 position, float maxValue, float size) {
|
|
Color color;
|
|
if (Application.isPlaying) {
|
|
float brightness = 0;
|
|
if (nucleus is Neuron neuron)
|
|
brightness = neuron.outputMagnitude / maxValue;
|
|
color = new Color(brightness, brightness, brightness, 1f);
|
|
}
|
|
else
|
|
color = Color.black;
|
|
DrawNucleus(nucleus, position, maxValue, size, color);
|
|
}
|
|
|
|
private void DrawNucleus(Nucleus nucleus, Vector3 position, float maxValue, float size, Color color) {
|
|
if (nucleus is MemoryCell) {
|
|
Handles.color = Color.white;
|
|
Handles.DrawWireDisc(position + Vector3.right * 10, Vector3.forward, size);
|
|
}
|
|
|
|
Handles.color = color;
|
|
Handles.DrawSolidDisc(position, Vector3.forward, size);
|
|
|
|
Handles.color = Color.white;
|
|
// Position the label in front of the disc
|
|
Vector3 labelPosition = position + (Vector3.forward * 0.1f);
|
|
|
|
GUIStyle style = new(EditorStyles.label) {
|
|
alignment = TextAnchor.MiddleCenter,
|
|
normal = { textColor = Color.white },
|
|
fontStyle = FontStyle.Bold,
|
|
};
|
|
|
|
if (nucleus is IReceptor receptor1) {
|
|
if (expandArray) {
|
|
// Put array indices above elements
|
|
style.alignment = TextAnchor.LowerCenter;
|
|
Vector3 labelPos1 = position + Vector3.down * (size + 5); // below disc
|
|
int colonPos1 = nucleus.name.IndexOf(":");
|
|
if (colonPos1 > 0) {
|
|
string extName = nucleus.name[(colonPos1 + 2)..];
|
|
Handles.Label(labelPos1, extName, style);
|
|
}
|
|
}
|
|
else {
|
|
// draw the array size label
|
|
if (color.grayscale > 0.5f)
|
|
style.normal.textColor = Color.black;
|
|
else
|
|
style.normal.textColor = Color.white;
|
|
Handles.Label(labelPosition, receptor1.nucleiArray.Length.ToString(), style);
|
|
style.normal.textColor = Color.white;
|
|
}
|
|
}
|
|
|
|
if (expandArray == false || nucleus is not IReceptor) {
|
|
// put name below nucleus
|
|
Vector3 labelPos = position - Vector3.down * (size + 5); // below neuron
|
|
style.alignment = TextAnchor.UpperCenter;
|
|
|
|
int colonPos = nucleus.name.IndexOf(":");
|
|
if (colonPos > 0 && colonPos < nucleus.name.Length - 2) {
|
|
// if it is an array, we should not show the :0 of the first element
|
|
string baseName = nucleus.name[..colonPos];
|
|
Handles.Label(labelPos, baseName, style);
|
|
}
|
|
else
|
|
Handles.Label(labelPos, nucleus.name, style);
|
|
|
|
}
|
|
|
|
// Draw Cluster ring
|
|
if (nucleus is Cluster) {
|
|
Handles.color = Color.white;
|
|
Handles.DrawWireDisc(position, Vector3.forward, size + 5);
|
|
}
|
|
|
|
// Tooltip
|
|
Rect neuronRect = new(position.x - size, position.y - size, size * 2, size * 2);
|
|
int id = GUIUtility.GetControlID(FocusType.Passive);
|
|
Event e = Event.current;
|
|
EventType et = e.GetTypeForControl(id);
|
|
if (e != null && neuronRect.Contains(e.mousePosition)) {
|
|
// Process Hover
|
|
HandleMouseHover(nucleus, neuronRect);
|
|
// Process click
|
|
if (e.type == EventType.MouseDown && e.button == 0) {
|
|
// Consume the event so the scene doesn't also handle it
|
|
e.Use();
|
|
HandleClicked(nucleus);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void HandleMouseHover(Nucleus nucleus, Rect rect) {
|
|
GUIContent tooltip;
|
|
if (nucleus is Neuron neuron) {
|
|
tooltip = new(
|
|
$"{nucleus.name}" +
|
|
$"\nValue: {neuron.outputMagnitude}");
|
|
}
|
|
else
|
|
tooltip = new($"{nucleus.name}");
|
|
|
|
Vector2 mousePosition = Event.current.mousePosition;
|
|
|
|
// Display tooltip with some offset
|
|
Vector2 tooltipSize = GUI.skin.box.CalcSize(tooltip);
|
|
Rect tooltipRect = new Rect(mousePosition.x + 10, mousePosition.y + 10, tooltipSize.x, tooltipSize.y);
|
|
|
|
GUI.Box(tooltipRect, tooltip);
|
|
}
|
|
|
|
private void HandleClicked(Nucleus nucleus) {
|
|
if (nucleus == this.currentNucleus) {
|
|
if (nucleus is Receptor || nucleus is ClusterReceptor)
|
|
expandArray = !expandArray;
|
|
else
|
|
expandArray = false;
|
|
}
|
|
// else if (nucleus is ReceptorInstance receptor) {
|
|
// this.currentNucleus = receptor.receptor;
|
|
// expandArray = false;
|
|
// BuildLayers();
|
|
// }
|
|
else {
|
|
this.currentNucleus = nucleus;
|
|
expandArray = false;
|
|
BuildLayers();
|
|
}
|
|
}
|
|
|
|
private VisualElement inspectorIMGUIContainer;
|
|
private bool showSynapses = true;
|
|
private bool showActivation = true;
|
|
protected bool breakOnWake = false;
|
|
protected bool trace = false;
|
|
void DrawInspector(VisualElement inspectorContainer) {
|
|
if (inspectorContainer == null)
|
|
return;
|
|
|
|
inspectorContainer.Clear();
|
|
if (this.currentNucleus == null)
|
|
return;
|
|
|
|
// create a SerializedObject wrapper so Unity inspector controls work (and Undo)
|
|
SerializedObject so = new(prefabAsset);
|
|
this.inspectorIMGUIContainer = new IMGUIContainer(() => InspectorHandler(so));
|
|
|
|
inspectorContainer.Add(inspectorIMGUIContainer);
|
|
}
|
|
|
|
void InspectorHandler(SerializedObject serializedObject) {
|
|
bool anythingChanged = false;
|
|
|
|
if (serializedObject == null || serializedObject.targetObject == null)
|
|
return;
|
|
|
|
if (this.currentNucleus == null)
|
|
return;
|
|
|
|
serializedObject.Update();
|
|
|
|
GUIStyle headerStyle = new(EditorStyles.boldLabel) {
|
|
alignment = TextAnchor.MiddleLeft,
|
|
margin = new RectOffset(10, 0, 4, 4)
|
|
};
|
|
GUIStyle boldTextFieldStyle = new(EditorStyles.textField) {
|
|
fontStyle = FontStyle.Bold
|
|
};
|
|
|
|
GUILayout.Label(this.currentNucleus.GetType().ToString(), headerStyle);
|
|
string newName = EditorGUILayout.TextField(this.currentNucleus.name, boldTextFieldStyle);
|
|
if (newName != this.currentNucleus.name) {
|
|
this.currentNucleus.name = newName;
|
|
this.prefab.RefreshOutputs();
|
|
outputsField.choices = this.prefab.outputs.Select(output => output.name).ToList();
|
|
anythingChanged = true;
|
|
}
|
|
|
|
if (Application.isPlaying) {
|
|
if (currentNucleus is Neuron currentNeuron1) {
|
|
GUIContent nameLabel = new("Output", currentNeuron1.outputValue.ToString());
|
|
EditorGUILayout.FloatField(nameLabel, currentNeuron1.outputMagnitude);
|
|
}
|
|
else
|
|
EditorGUILayout.LabelField(" ");
|
|
}
|
|
else
|
|
EditorGUILayout.LabelField(" ");
|
|
|
|
if (this.currentNucleus is MemoryCell memory) {
|
|
memory.staticMemory = EditorGUILayout.Toggle("Static Memory", memory.staticMemory);
|
|
}
|
|
|
|
if (this.currentNucleus is IReceptor receptor1) {
|
|
EditorGUILayout.BeginHorizontal();
|
|
EditorGUILayout.IntField("Array size", receptor1.nucleiArray.Count());
|
|
if (GUILayout.Button("Add")) {
|
|
Undo.RecordObject(prefabAsset, "Array add " + prefabAsset.name);
|
|
receptor1.AddReceptorElement(this.prefab);
|
|
anythingChanged = true;
|
|
}
|
|
if (GUILayout.Button("Del")) {
|
|
Undo.RecordObject(prefabAsset, "Array delete " + prefabAsset.name);
|
|
receptor1.RemoveReceptorElement();
|
|
anythingChanged = true;
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
}
|
|
|
|
// Synapses
|
|
|
|
if (this.currentNucleus is not Receptor && this.currentNucleus is not ClusterReceptor) {
|
|
showSynapses = EditorGUILayout.BeginFoldoutHeaderGroup(showSynapses, "Synapses");
|
|
if (showSynapses) {
|
|
if (this.currentNucleus is Neuron neuron2) {
|
|
Neuron.CombinatorType newCombinator = (Neuron.CombinatorType)EditorGUILayout.EnumPopup("Combinator", neuron2.combinator);
|
|
anythingChanged |= newCombinator != neuron2.combinator;
|
|
neuron2.combinator = newCombinator;
|
|
}
|
|
|
|
EditorGUIUtility.wideMode = true;
|
|
EditorGUIUtility.labelWidth = 100;
|
|
Vector3 newBias = EditorGUILayout.Vector3Field("Bias", this.currentNucleus.bias);
|
|
anythingChanged |= newBias != this.currentNucleus.bias;
|
|
this.currentNucleus.bias = newBias;
|
|
|
|
Nucleus[] array = null;
|
|
int elementIx = -1;
|
|
if (this.currentNucleus.synapses.Count > 0) {
|
|
Synapse[] synapses = this.currentNucleus.synapses.ToArray();
|
|
foreach (Synapse synapse in synapses) {
|
|
if (synapse.neuron == null)
|
|
continue;
|
|
|
|
if (array != null) {
|
|
if (synapse.neuron.parent is Cluster iCluster && elementIx > 0) {
|
|
int thisElementIx = Cluster.GetNucleusIndex(iCluster.clusterNuclei, synapse.neuron);
|
|
if (thisElementIx == elementIx)
|
|
continue;
|
|
else
|
|
elementIx = thisElementIx;
|
|
}
|
|
// if (array.Contains(synapse.nucleus))
|
|
// continue;
|
|
else if (array.Contains(synapse.neuron.parent))
|
|
continue;
|
|
}
|
|
else {
|
|
if (synapse.neuron.parent is IReceptor iReceptor) {
|
|
array = iReceptor.nucleiArray;
|
|
if (iReceptor is Cluster iCluster)
|
|
elementIx = Cluster.GetNucleusIndex(iCluster.clusterNuclei, synapse.neuron);
|
|
}
|
|
// else if (synapse.nucleus is Receptor receptor2) // && receptor2.array != null && receptor2.array.nuclei.Length > 1)
|
|
// array = receptor2.nucleiArray;
|
|
}
|
|
|
|
EditorGUILayout.Space();
|
|
|
|
if (Application.isPlaying) {
|
|
if (synapse.neuron is Neuron synapseNeuron) {
|
|
Vector3 value = synapseNeuron.outputValue * synapse.weight;
|
|
GUIContent synapseValueLabel = new(synapse.neuron.name, synapseNeuron.outputValue.ToString());
|
|
EditorGUILayout.FloatField(synapseValueLabel, synapseNeuron.outputMagnitude);
|
|
}
|
|
}
|
|
else {
|
|
EditorGUILayout.BeginHorizontal();
|
|
|
|
if (synapse.neuron.parent != null && synapse.neuron.parent != this.currentNucleus) {
|
|
// If it is a cluster
|
|
GUIStyle labelStyle = new(GUI.skin.label);
|
|
float labelWidth = 200;
|
|
if (synapse.neuron.clusterPrefab != null) {
|
|
labelWidth = labelStyle.CalcSize(new GUIContent($"{synapse.neuron.parent.baseName}.")).x;
|
|
GUILayout.Label($"{synapse.neuron.parent.baseName}", GUILayout.Width(labelWidth));
|
|
}
|
|
string[] options = synapse.neuron.parent.clusterNuclei.Select(n => n.name).ToArray();
|
|
int selectedIndex = System.Array.IndexOf(options, synapse.neuron.name);
|
|
int newIndex = EditorGUILayout.Popup(selectedIndex, options);
|
|
if (newIndex != selectedIndex && synapse.neuron.parent.clusterNuclei[newIndex] is Neuron newNeuron)
|
|
ChangeSynapse(synapse, newNeuron);
|
|
}
|
|
else
|
|
GUILayout.Label(synapse.neuron.name);
|
|
|
|
bool disconnecting = GUILayout.Button("Disconnect", GUILayout.Width(80));
|
|
if (disconnecting && synapse.neuron is Neuron synapseNeuron) {
|
|
synapseNeuron.RemoveReceiver(this.currentNucleus);
|
|
this.prefab.GarbageCollection();
|
|
anythingChanged = true;
|
|
}
|
|
EditorGUILayout.EndHorizontal();
|
|
|
|
}
|
|
|
|
EditorGUI.indentLevel++;
|
|
float newWeight = EditorGUILayout.FloatField("Weight", synapse.weight);
|
|
if (newWeight != synapse.weight) {
|
|
if (synapse.neuron.parent is IReceptor receptor) {
|
|
Nucleus[] receptorArray = receptor.nucleiArray;
|
|
foreach (Synapse s in this.currentNucleus.synapses) {
|
|
if (s.neuron.parent is IReceptor r && r.nucleiArray == receptorArray)
|
|
s.weight = newWeight;
|
|
}
|
|
}
|
|
else
|
|
synapse.weight = newWeight;
|
|
anythingChanged = true;
|
|
}
|
|
EditorGUI.indentLevel--;
|
|
}
|
|
}
|
|
|
|
EditorGUILayout.Space();
|
|
anythingChanged |= ConnectNucleus(this.prefab, this.currentNucleus);
|
|
anythingChanged |= AddSynapse(this.prefab, this.currentNucleus);
|
|
}
|
|
EditorGUILayout.EndFoldoutHeaderGroup();
|
|
}
|
|
|
|
// Activation
|
|
|
|
if (this.currentNucleus is not Cluster) {
|
|
EditorGUILayout.Space();
|
|
showActivation = EditorGUILayout.BeginFoldoutHeaderGroup(showActivation, "Activation");
|
|
if (showActivation) {
|
|
if (this.currentNucleus is Neuron neuron) {
|
|
if (this.currentNucleus is not MemoryCell) {
|
|
EditorGUILayout.BeginHorizontal();
|
|
EditorGUILayout.LabelField("Activation Curve", GUILayout.Width(150));
|
|
if (neuron.curveMax > 0)
|
|
EditorGUILayout.CurveField(neuron.curve, Color.cyan, new Rect(0, 0, 1, neuron.curveMax));
|
|
else
|
|
EditorGUILayout.CurveField(neuron.curve, Color.cyan, new Rect(0, neuron.curveMax, 1, -neuron.curveMax));
|
|
Neuron.CurvePresets newPreset = (Neuron.CurvePresets)EditorGUILayout.EnumPopup(neuron.curvePreset, GUILayout.Width(100));
|
|
anythingChanged |= newPreset != neuron.curvePreset;
|
|
neuron.curvePreset = newPreset;
|
|
EditorGUILayout.EndHorizontal();
|
|
}
|
|
if (neuron is Receptor receptor2) {
|
|
if (receptor2.nucleiArray == null || receptor2.nucleiArray.Count() == 0)
|
|
receptor2.array = new NucleusArray(neuron);
|
|
}
|
|
}
|
|
|
|
EditorGUILayout.Space();
|
|
}
|
|
EditorGUILayout.EndFoldoutHeaderGroup();
|
|
}
|
|
|
|
if (GUILayout.Button("Delete this neuron"))
|
|
DeleteNucleus(this.currentNucleus);
|
|
|
|
if (this.currentNucleus is Cluster subCluster) {
|
|
if (GUILayout.Button("Edit Cluster"))
|
|
EditCluster(subCluster);
|
|
}
|
|
|
|
EditorGUILayout.Space();
|
|
breakOnWake = EditorGUILayout.Toggle("Break on wake", breakOnWake);
|
|
if (breakOnWake && this.currentNucleus is Neuron currentNeuron) {
|
|
if (currentNeuron.isSleeping == false)
|
|
Debug.Break();
|
|
}
|
|
trace = EditorGUILayout.Toggle("Trace", trace);
|
|
this.currentNucleus.trace = trace;
|
|
|
|
serializedObject.ApplyModifiedProperties();
|
|
if (anythingChanged) {
|
|
EditorUtility.SetDirty(prefabAsset);
|
|
AssetDatabase.SaveAssets();
|
|
}
|
|
}
|
|
|
|
void OnSceneGUI(SceneView sceneView) {
|
|
if (this.gameObject != null) {
|
|
if (this.currentNucleus is IReceptor receptor) {
|
|
foreach (Nucleus nucleus in receptor.nucleiArray) {
|
|
if (nucleus is Neuron neuron) {
|
|
Vector3 worldVector = this.gameObject.transform.TransformVector(neuron.outputValue);
|
|
Handles.color = Color.yellow;
|
|
Handles.DrawLine(this.gameObject.transform.position, this.gameObject.transform.position + worldVector);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
if (this.currentNucleus is Neuron currentNeuron) {
|
|
Vector3 worldVector = this.gameObject.transform.TransformVector(currentNeuron.outputValue);
|
|
Handles.color = Color.yellow;
|
|
Handles.DrawLine(this.gameObject.transform.position, this.gameObject.transform.position + worldVector);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#region Synapses
|
|
|
|
protected virtual void AddInput(Nucleus.Type selectedType, Nucleus nucleus) {
|
|
switch (selectedType) {
|
|
case Nucleus.Type.Neuron:
|
|
AddNeuronInput(nucleus);
|
|
break;
|
|
case Nucleus.Type.MemoryCell:
|
|
AddMemoryCellInput(nucleus);
|
|
break;
|
|
// case Nucleus.Type.Selector:
|
|
// AddSelectorInput(nucleus);
|
|
// break;
|
|
case Nucleus.Type.Cluster:
|
|
AddClusterInput(nucleus);
|
|
break;
|
|
// case Nucleus.Type.Pulsar:
|
|
// AddPulsarInput(nucleus);
|
|
// break;
|
|
case Nucleus.Type.Receptor:
|
|
AddReceptorInput(nucleus);
|
|
break;
|
|
// case Nucleus.Type.ReceptorArray:
|
|
// AddReceptorArrayInput(nucleus);
|
|
// break;
|
|
case Nucleus.Type.ClusterReceptor:
|
|
AddClusterReceptorInput(nucleus);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
protected virtual void AddNeuronInput(Nucleus nucleus) {
|
|
Neuron newNeuroid = new(this.prefab, "New neuron");
|
|
newNeuroid.AddReceiver(nucleus);
|
|
this.currentNucleus = newNeuroid;
|
|
BuildLayers();
|
|
}
|
|
|
|
protected virtual void AddMemoryCellInput(Nucleus nucleus) {
|
|
MemoryCell newMemory = new(this.prefab, "New memory cell");
|
|
newMemory.AddReceiver(nucleus);
|
|
this.currentNucleus = newMemory;
|
|
BuildLayers();
|
|
}
|
|
|
|
protected virtual void AddClusterInput(Nucleus nucleus) {
|
|
ClusterPickerWindow.ShowPicker(brain => OnClusterPicked(nucleus, brain), "Select Cluster");
|
|
}
|
|
private void OnClusterPicked(Nucleus nucleus, ClusterPrefab prefab) {
|
|
Cluster subclusterInstance = new(prefab, this.prefab);
|
|
subclusterInstance.defaultOutput.AddReceiver(nucleus);
|
|
}
|
|
|
|
protected virtual void AddReceptorInput(Nucleus nucleus) {
|
|
Receptor newReceptor = new(this.prefab, "New Receptor");
|
|
newReceptor.AddReceiver(nucleus);
|
|
this.currentNucleus = newReceptor;
|
|
BuildLayers();
|
|
}
|
|
|
|
protected virtual void AddClusterReceptorInput(Nucleus nucleus) {
|
|
ClusterPickerWindow.ShowPicker(prefab => OnClusterReceptorPicked(nucleus, prefab), "Select Cluster");
|
|
}
|
|
private void OnClusterReceptorPicked(Nucleus nucleus, ClusterPrefab selectedPrefab) {
|
|
ClusterReceptor clusterInstance = new(selectedPrefab, this.prefab, "New " + selectedPrefab.name);
|
|
clusterInstance.defaultOutput.AddReceiver(nucleus);
|
|
this.currentNucleus = clusterInstance;
|
|
BuildLayers();
|
|
}
|
|
|
|
private void EditCluster(Cluster subCluster) {
|
|
// May be used with storedPrefab...
|
|
Selection.activeObject = subCluster.prefab;
|
|
EditorGUIUtility.PingObject(subCluster.prefab);
|
|
var editor = Editor.CreateEditor(subCluster.prefab);
|
|
}
|
|
|
|
int selectedConnectNucleus = -1;
|
|
// Connect to another nucleus in the same cluster
|
|
protected virtual bool ConnectNucleus(ClusterPrefab cluster, Nucleus nucleusToConnect) {
|
|
if (cluster == null)
|
|
return false;
|
|
|
|
IEnumerable<Nucleus> synapseNuclei = this.currentNucleus.synapses
|
|
.Where(synapse => synapse.neuron != null)
|
|
.Select(synapse => synapse.neuron);
|
|
|
|
IEnumerable<Nucleus> nuclei = cluster.nuclei
|
|
.Except(synapseNuclei);
|
|
IEnumerable<string> nucleiNames = nuclei
|
|
.Select(n => {
|
|
int idx = n.name.IndexOf(':');
|
|
return idx < 0 ? n.name : n.name[..idx];
|
|
})
|
|
.Distinct();
|
|
|
|
string[] names = nucleiNames.ToArray();
|
|
EditorGUILayout.BeginHorizontal();
|
|
selectedConnectNucleus = EditorGUILayout.Popup(selectedConnectNucleus, names);
|
|
bool connecting = GUILayout.Button("Connect", GUILayout.Width(80));
|
|
EditorGUILayout.EndHorizontal();
|
|
if (connecting) {
|
|
Nucleus nucleus = nuclei.ElementAt(selectedConnectNucleus);
|
|
if (nucleus is IReceptor receptor)
|
|
receptor.AddArrayReceiver(this.currentNucleus);
|
|
else if (nucleus is Neuron neuron)
|
|
neuron.AddReceiver(this.currentNucleus);
|
|
else if (nucleus is Cluster subCluster)
|
|
subCluster.defaultOutput.AddReceiver(this.currentNucleus);
|
|
|
|
}
|
|
return connecting;
|
|
}
|
|
|
|
protected virtual void DeleteNucleus(Nucleus nucleus) {
|
|
if (nucleus == null)
|
|
return;
|
|
|
|
if (nucleus is Neuron neuron) {
|
|
foreach (Nucleus receiver in neuron.receivers) {
|
|
if (receiver != null) {
|
|
this.currentNucleus = receiver;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
this.prefab.nuclei.Remove(nucleus);
|
|
|
|
if (outputsField.value == nucleus.name) {
|
|
this.prefab.RefreshOutputs();
|
|
outputsField.choices = this.prefab.outputs.Select(output => output.name).ToList();
|
|
outputsField.index = 0;
|
|
}
|
|
|
|
Neuron.Delete(nucleus);
|
|
|
|
this.currentNucleus = this.prefab.output;
|
|
BuildLayers();
|
|
}
|
|
|
|
Nucleus.Type selectedType = Nucleus.Type.None;
|
|
protected virtual bool AddSynapse(ClusterPrefab cluster, Nucleus nucleus) {
|
|
if (cluster == null)
|
|
return false;
|
|
|
|
EditorGUILayout.BeginHorizontal();
|
|
selectedType = (Nucleus.Type)EditorGUILayout.EnumPopup(selectedType);
|
|
bool connecting = GUILayout.Button("Add", GUILayout.Width(80));
|
|
EditorGUILayout.EndHorizontal();
|
|
|
|
if (connecting) {
|
|
AddInput(selectedType, this.currentNucleus);
|
|
}
|
|
return connecting;
|
|
// if (selectedType == Nucleus.Type.None)
|
|
// return false;
|
|
|
|
// AddInput(selectedType, this.currentNucleus);
|
|
// return true;
|
|
}
|
|
|
|
protected virtual void ChangeSynapse(Synapse synapse, Neuron newNucleus) {
|
|
Neuron synapseNeuron = synapse.neuron as Neuron;
|
|
if (synapse.neuron.parent is Cluster subCluster && subCluster.prefab != this.prefab) {
|
|
if (synapse.neuron.parent is ClusterReceptor receptor) {
|
|
// the new nucleus is part of a (cluster) receptor,
|
|
// so we have to change all synapses to this nucleus array elements
|
|
int oldNucleusIx = Cluster.GetNucleusIndex(subCluster.clusterNuclei, synapse.neuron);
|
|
int newNucleusIx = Cluster.GetNucleusIndex(subCluster.clusterNuclei, newNucleus);
|
|
foreach (Nucleus element in receptor.nucleiArray) {
|
|
if (element is not ClusterReceptor clusterReceptor)
|
|
continue;
|
|
// Get the same neuron as the synapse.nucleus in a different element
|
|
// of the ClusterReceptor array
|
|
Nucleus oldElementNucleus = clusterReceptor.clusterNuclei[oldNucleusIx];
|
|
if (oldElementNucleus is not Neuron oldElementNeuron)
|
|
continue;
|
|
// Get the same neuron as newNucleus in a different element
|
|
// of the ClusterReceptor array
|
|
Nucleus newElementNucleus = clusterReceptor.clusterNuclei[newNucleusIx];
|
|
if (newElementNucleus is not Neuron newElementNeuron)
|
|
continue;
|
|
|
|
oldElementNeuron.RemoveReceiver(this.currentNucleus);
|
|
newElementNeuron.AddReceiver(this.currentNucleus);
|
|
// Now find the synapse which pointed to the old Neuron
|
|
// Synapse synapseForUpdate = this.currentNucleus.GetSynapse(oldElementNeuron);
|
|
// synapseForUpdate.nucleus = newElementNeuron;
|
|
}
|
|
}
|
|
else {
|
|
// it is a neuron in a subcluster
|
|
synapseNeuron.RemoveReceiver(this.currentNucleus);
|
|
newNucleus.AddReceiver(this.currentNucleus);
|
|
}
|
|
}
|
|
else {
|
|
synapseNeuron.RemoveReceiver(this.currentNucleus);
|
|
newNucleus.AddReceiver(this.currentNucleus);
|
|
}
|
|
}
|
|
|
|
protected virtual void DisconnectNucleus(Neuron nucleus) {
|
|
if (this.currentNucleus.clusterPrefab == null)
|
|
return;
|
|
string[] names = this.currentNucleus.synapses.Select(synapse => synapse.neuron.name).ToArray();
|
|
int selectedIndex = -1;
|
|
selectedIndex = EditorGUILayout.Popup("Disconnect from", selectedIndex, names);
|
|
if (selectedIndex >= 0 && selectedIndex < this.currentNucleus.clusterPrefab.nuclei.Count) {
|
|
Synapse synapse = this.currentNucleus.synapses[selectedIndex];
|
|
Neuron synapseNeuron = synapse.neuron as Neuron;
|
|
synapseNeuron.RemoveReceiver(this.currentNucleus);
|
|
}
|
|
}
|
|
|
|
#endregion Synapses
|
|
}
|
|
|
|
}
|
|
|
|
public class NeuroidLayer {
|
|
public int ix = 0;
|
|
public List<Nucleus> neuroids = new();
|
|
}
|
|
*/
|
|
} |