Merge pull request #11 from taoria/working-in-process

Working in process

TNode/Attribute/BlackboardSection.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using JetBrains.Annotations;
+
+namespace TNode.Attribute{
+    
+    /// <summary>
+    /// Use this attribute to declare a blackboard section ,a blackboard section is a group of  variables with same types
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Field, AllowMultiple = false, Inherited = false)]
+    [BaseTypeRequired(typeof(List<>))]
+    
+    public class BlackboardSection:System.Attribute{
+        
+    }
+}

TNode/Attribute/BlackboardSection.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 773d073006dc4dd488e18b38165efd5a
+timeCreated: 1656942977

TNode/Editor/BaseViews/DataGraphView.cs

@@ -111,7 +111,7 @@ namespace TNode.Editor.BaseViews{
         private T _data;
         private bool _isInspectorOn;
         
-        private SearchWindowProvider _searchWindowProvider;
+        private NodeSearchWindowProvider _nodeSearchWindowProvider;
         private NodeInspector _nodeInspector;
         public GraphEditor<T> Owner;
         private Dictionary<string,Node> _nodeDict = new();
@@ -126,7 +126,51 @@ namespace TNode.Editor.BaseViews{
                 ResetGraphView();
             }
         }
+        public event DataChangedEventHandler OnDataChanged;
+        public delegate void DataChangedEventHandler(object sender, DataChangedEventArgs<T> e);
+     
+        //A Constructor for the DataGraphView ,never to override it
+        public DataGraphView(){
+            
+            styleSheets.Add(Resources.Load<StyleSheet>("GraphViewBackground"));
+            var grid = new GridBackground();
+            Insert(0,grid);
+            grid.StretchToParentSize();
+            this.AddManipulator(new ContentDragger());
+            this.AddManipulator(new SelectionDragger());
+            this.AddManipulator(new RectangleSelector());
+            SetupZoom(ContentZoomer.DefaultMinScale, ContentZoomer.DefaultMaxScale);
+            OnInit();
+        }
+        private void ConstructDefaultBehaviour(){
+            //Register a right click context menu
+            ConstructViewContextualMenu();
+        }
+
+        public void ConstructViewContextualMenu(){
+            
+            //Rebuild the contextual menu
+            
+            this.RegisterCallback<ContextualMenuPopulateEvent>(evt => {
+                Vector2 editorPosition = Owner.position.position;
+                //Remove all the previous menu items
+                evt.menu.MenuItems().Clear();
+                evt.menu.AppendAction("Create Node", dma => {
+                    var dmaPos = dma.eventInfo.mousePosition+editorPosition;
+                    SearchWindowContext searchWindowContext = new SearchWindowContext(dmaPos,200,200);
+                    var searchWindow = ScriptableObject.CreateInstance<NodeSearchWindowProvider>();
+                    searchWindow.Setup(typeof(T),this,Owner);
+                    SearchWindow.Open(searchWindowContext, searchWindow);
+                });
+ 
+            });
+           
+        }
 
+        private void OnInit(){
+            ConstructDefaultBehaviour();
+            OnGraphViewCreate();
+        }
         public void ResetGraphView(){
             //Clear all nodes
             foreach (var node in nodes){
@@ -145,8 +189,8 @@ namespace TNode.Editor.BaseViews{
                 var nodeType = dataNode.GetType();
                 //Get the derived type of NodeAttribute View from the node type
            
-                var nodePos = Owner.graphEditorData.nodesData.
+                var nodePos = Owner.graphEditorData.graphElementsData.
-                    FirstOrDefault(x => x.nodeGuid == dataNode.id)?.nodePos??new Rect(0,0,200,200);
+                    FirstOrDefault(x => x.guid == dataNode.id)?.pos??new Rect(0,0,200,200);
                 
                 AddTNode(dataNode,nodePos);
             }
@@ -157,46 +201,23 @@ namespace TNode.Editor.BaseViews{
                 var inputNodeView = _nodeDict[inputNode.id];
                 var outputNodeView = _nodeDict[outputNode.id];
                 Edge newEdge = new Edge(){
+                 
                     input = inputNodeView.inputContainer.Q<Port>(edge.inPort.portName),
                     output = outputNodeView.outputContainer.Q<Port>(edge.outPort.portName)
                 };
+                Debug.Log(edge.inPort.portName);
+                Debug.Log(edge.outPort.portName);
                 newEdge.input?.Connect(newEdge);
                 newEdge.output?.Connect(newEdge);
                 AddElement(newEdge);
             }
             _nodeDict.Clear();
         }
-        //A Constructor for the DataGraphView ,never to override it
-        public DataGraphView(){
-            
-            styleSheets.Add(Resources.Load<StyleSheet>("GraphViewBackground"));
-            var grid = new GridBackground();
-            Insert(0,grid);
-            grid.StretchToParentSize();
-            this.AddManipulator(new ContentDragger());
-            this.AddManipulator(new SelectionDragger());
-            this.AddManipulator(new RectangleSelector());
-            SetupZoom(ContentZoomer.DefaultMinScale, ContentZoomer.DefaultMaxScale);
-            OnInit();
-        }
         //OnDataChanged event
-        public event DataChangedEventHandler OnDataChanged;
-        public delegate void DataChangedEventHandler(object sender, DataChangedEventArgs<T> e);
 
 
-        private void ConstructDefaultBehaviour(){
-            //Register a right click context menu
-            //ConstructContextualMenuOption();
-        }
         
-        public void ConstructViewContextualMenu(EventCallback<ContextualMenuPopulateEvent> callback){
-            RegisterCallback<ContextualMenuPopulateEvent>(callback);
-        }
 
-        private void OnInit(){
-            ConstructDefaultBehaviour();
-            OnGraphViewCreate();
-        }
 
         public virtual void CreateInspector(){
             NodeInspector nodeInspector = new NodeInspector();
@@ -213,6 +234,15 @@ namespace TNode.Editor.BaseViews{
 
         public void CreateBlackBoard(){
             var blackboard = new Blackboard();
+            //Blackboard add "Add Node" button
+            blackboard.Add(new BlackboardSection(){
+                title = "Hello World",
+            });
+            blackboard.addItemRequested = (item) => {
+                //Create a sub window for the blackboard to show the selection
+                var subWindow = ScriptableObject.CreateInstance<NodeSearchWindowProvider>();
+            };
+            
             //Set black board to left side of the view
             blackboard.SetPosition(new Rect(0,0,200,600));
             this.Add(blackboard);
@@ -234,19 +264,19 @@ namespace TNode.Editor.BaseViews{
         }
 
         public void SaveEditorData(GraphEditorData graphEditorData){
-            graphEditorData.nodesData?.Clear();
+            graphEditorData.graphElementsData?.Clear();
             //iterator nodes
-            if (graphEditorData.nodesData == null){
+            if (graphEditorData.graphElementsData == null){
-                graphEditorData.nodesData = new List<NodeEditorData>();
+                graphEditorData.graphElementsData = new List<GraphElementEditorData>();
             }
             foreach (var node in this.nodes){
-                var nodeEditorData = new NodeEditorData{
+                var nodeEditorData = new GraphElementEditorData{
-                    nodePos = node.GetPosition(),
+                    pos = node.GetPosition(),
                 };
                 if (node is INodeView nodeView){
-                    nodeEditorData.nodeGuid = nodeView.GetNodeData().id;
+                    nodeEditorData.guid = nodeView.GetNodeData().id;
                 }
-                graphEditorData.nodesData.Add(nodeEditorData);
+                graphEditorData.graphElementsData.Add(nodeEditorData);
                 EditorUtility.SetDirty(graphEditorData);
             }
         }
@@ -278,11 +308,11 @@ namespace TNode.Editor.BaseViews{
                     var outputNodeData = outputNode.GetNodeData();
                     var newNodeLink = new NodeLink(new PortInfo(){
                         nodeDataId = inputNodeData.id,
-                        portName = edge.input.name
+                        portName = edge.input.portName,
 
                     }, new PortInfo(){
                         nodeDataId = outputNodeData.id,
-                        portName = edge.output.name
+                        portName = edge.output.portName
                     });
                     links.Add(newNodeLink);
                 }
@@ -335,6 +365,32 @@ namespace TNode.Editor.BaseViews{
                     nodeViewInterface.SetNodeData(nodeData);
                 }
                 _nodeDict.Add(nodeData.id, nodeView);
+                
+                //register an callback ,when right click context menu
+                nodeView.RegisterCallback<ContextClickEvent>(evt => {
+                    var menu = new GenericMenu();
+                    menu.AddItem(new GUIContent("Delete"), false, () => {
+                        RemoveElement(nodeView);
+                        if (nodeView is INodeView tNodeView){
+                            var nodeData1 = tNodeView.GetNodeData();
+                            _data.NodeDictionary.Remove(nodeData1.id);
+                            _nodeDict.Remove(nodeData1.id);
+                            //Break all edges connected to this node
+                            foreach (var edge in edges){
+                                if (edge.input.node == nodeView || edge.output.node == nodeView){
+                                    RemoveElement(edge);
+                                }
+                            }
+                            Owner.graphEditorData.graphElementsData.RemoveAll(x => x.guid == nodeData1.id);
+                        }
+                    });
+                    menu.ShowAsContext();
+                });
+                
+                
+                
+   
+                
             }
         }
 

TNode/Editor/BaseViews/NodeView.cs

@@ -69,6 +69,7 @@ namespace TNode.Editor.BaseViews{
                     Port port = InstantiatePort(Orientation.Horizontal, Direction.Output,Port.Capacity.Multi,propertyInfo.PropertyType);
                     this.outputContainer.Add(port);
                     port.portName = propertyInfo.Name;
+                    port.name = propertyInfo.Name;
                 }
             }
             foreach (var propertyInfo in propertyInfos){
@@ -78,6 +79,7 @@ namespace TNode.Editor.BaseViews{
                     Port port = InstantiatePort(Orientation.Horizontal, Direction.Input,Port.Capacity.Multi,propertyInfo.PropertyType);
                     this.inputContainer.Add(port);
                     port.portName = propertyInfo.Name;
+                    port.name = propertyInfo.Name;
                 }
             }
         }

TNode/Editor/BaseViews/SimpleGraphSubWindow.cs

@@ -41,7 +41,7 @@ namespace TNode.BaseViews{
         }
 
         public void ResetPos(GraphEditorData editorData){
-            var res = editorData.subWindowPos.FirstOrDefault(x => x.nodeGuid == this.GetPersistenceId());
+            var res = editorData.graphElementsData.FirstOrDefault(x => x.guid == this.GetPersistenceId());
         }
 
         public void SavePos(GraphEditorData editorData){

TNode/Editor/EditorPersistence/GraphEditorData.cs

@@ -2,14 +2,12 @@
 using TNode.Editor.EditorPersistence;
 using TNode.Editor.Model;
 using UnityEngine;
+using UnityEngine.Serialization;
 
 namespace TNode.Editor{
     
-    [CreateAssetMenu(fileName = "NodeAttribute Editor Config", menuName = "TNode/NodeAttribute Editor Config")]
+    [CreateAssetMenu(fileName = "Graph Editor Data", menuName = "TNode/Graph Editor Data")]
     public class GraphEditorData:ScriptableObject{
-        public List<NodeEditorData> nodesData;
+        public List<GraphElementEditorData> graphElementsData;
-        public List<NodeEditorData> subWindowPos;
-        
-        public List<IGraphViewPersistence> graphViewPersistence;
     }
 }

TNode/Editor/EditorPersistence/GraphElementEditorData.cs

@@ -6,8 +6,8 @@ using UnityEngine.Serialization;
 namespace TNode.Editor.Model{
     [Serializable]
     
-    public class NodeEditorData{
+    public class GraphElementEditorData{
-        public string nodeGuid;
+        public string guid;
-        public Rect nodePos;
+        public Rect pos;
     }
 }

TNode/Editor/GraphBlackboard.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 476d14ab24734294b206f16006438e60
+timeCreated: 1656941713

TNode/Editor/GraphBlackboard/GraphBlackboard.cs

@@ -0,0 +1,12 @@
+using TNode.Models;
+using UnityEditor.Experimental.GraphView;
+
+namespace TNode.Editor.GraphBlackboard{
+    /// <summary>
+    /// Implement this class to create graph black board for specified graph
+    /// </summary>
+    public class GraphBlackboard<T>:Blackboard where T:BlackboardData{
+        public T BlackboardData;
+        
+    }
+}

TNode/Editor/GraphBlackboard/GraphBlackboard.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 285d836db7e04e2f989069277fd1853a
+timeCreated: 1656941728

TNode/Editor/GraphEditor.cs

@@ -39,19 +39,6 @@ namespace TNode.Editor{
             _graphView = NodeEditorExtensions.CreateInstance<DataGraphView<T>>();
             rootVisualElement.Add(_graphView);
             _graphView.StretchToParentSize();
-            _graphView.ConstructViewContextualMenu(evt => {
-                //Current issue is that the search window don't show up at  the exact position of the mouse click by dma.eventInfo.mousePosition
-                //So I have to manually set the position of the search window to fit the mouse click position by add an offset driven by Editor's position
-                //Maybe a better way exists to fix this issue
-                Vector2 editorPosition = this.position.position;
-                evt.menu.AppendAction("Create Node", dma => {
-                    var dmaPos = dma.eventInfo.mousePosition+editorPosition;
-                    SearchWindowContext searchWindowContext = new SearchWindowContext(dmaPos,200,200);
-                    var searchWindow = CreateInstance<SearchWindowProvider>();
-                    searchWindow.Setup(typeof(T),_graphView,this);
-                    SearchWindow.Open(searchWindowContext, searchWindow);
-                });
-            });
         }
 
         private void DefineGraphEditorActions(){

TNode/Editor/Search.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 4fe6a069e0cc45158b4749dbdb7fd399
+timeCreated: 1656942698

TNode/Editor/Search/BlackboardSearchWindowProvider.cs

@@ -0,0 +1,5 @@
+namespace TNode.Editor{
+    public class BlackboardSearchWindowProvider{
+        
+    }
+}

TNode/Editor/Search/BlackboardSearchWindowProvider.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 73c77be1f9364a0199d95eea7e7c0101
+timeCreated: 1656942712

TNode/Editor/Search/NodeSearchWindowProvider.cs

@@ -12,7 +12,7 @@ using UnityEngine;
 using UnityEngine.UIElements;
 
 namespace TNode.Editor{
-    public class SearchWindowProvider:ScriptableObject,ISearchWindowProvider{
+    public class NodeSearchWindowProvider:ScriptableObject,ISearchWindowProvider{
         private Type _graphType;
         private GraphView _graphView;
         private EditorWindow _editor;
@@ -58,7 +58,7 @@ namespace TNode.Editor{
             return false;
         }
         
-        public SearchWindowProvider(){
+        public NodeSearchWindowProvider(){
         }
     }
 }

TNode/JsonSerialize/JsonSerializeTool.cs

@@ -1,15 +1,27 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
+using System.Linq;
 using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Serialization;
+
 
 namespace TNode.JsonSerialize{
-    public class JsonSerializeTool{
+    public static class JsonSerializeTool{
+        class WritablePropertiesOnlyResolver : DefaultContractResolver
+        {
+            protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
+            {
+                IList<JsonProperty> props = base.CreateProperties(type, memberSerialization);
+                return props.Where(p => p.Writable).ToList();
+            }
+        }
         public static JsonSerializerSettings JsonSerializerSettings = new JsonSerializerSettings(){
             ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
             NullValueHandling = NullValueHandling.Ignore,
             DateFormatString = "yyyy-MM-dd HH:mm:ss",
             Converters = new List<JsonConverter> { new Vector3Converter() },
-            TypeNameHandling = TypeNameHandling.Auto
+            TypeNameHandling = TypeNameHandling.Auto,
+            ContractResolver = new WritablePropertiesOnlyResolver()
 
         };
 

TNode/JsonSerialize/Vector3Converter.cs

@@ -21,7 +21,6 @@ namespace TNode.JsonSerialize{
 
                 if (array != null) return new Vector3(array[0], array[1], array[2]);
             }
-
             return default(Vector3);
             
         }

TNode/Models/BlackDragNodeData.cs

@@ -0,0 +1,12 @@
+using Newtonsoft.Json;
+using TNode.Attribute.Ports;
+
+namespace TNode.Models{
+    public class BlackDragNodeData<T>:NodeData{
+        [JsonIgnore]
+        private string _blackDragData;
+        [JsonIgnore]
+        private BlackboardData _blackboardData;
+        
+    }
+}

TNode/Models/BlackDragNodeData.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f6434bdf404f4ee892274b61db24d0f8
+timeCreated: 1656943697

TNode/Models/BlackboardData.cs

@@ -0,0 +1,6 @@
+namespace TNode.Models{
+
+    public class BlackboardData{
+        
+    }
+}

TNode/Models/BlackboardData.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 395a389740e542ea9930248876904aee
+timeCreated: 1656940618

TNode/Models/GraphData.cs

@@ -2,7 +2,9 @@
 using System.Collections.Generic;
 using UnityEngine;
 using Newtonsoft.Json;
+using TNode.Editor;
 using TNode.JsonSerialize;
+using UnityEditor.Experimental.GraphView;
 using UnityEngine.Serialization;
 
 namespace TNode.Models{
@@ -10,24 +12,27 @@ namespace TNode.Models{
     public class GraphData:ScriptableObject,ISerializationCallbackReceiver{
         [SerializeField]
         public Dictionary<string,NodeData> NodeDictionary = new Dictionary<string,NodeData>();
-        public List<NodeLink> nodeLinks = new List<NodeLink>();
+        public List<NodeLink> nodeLinks = new();
-        
+        public BlackboardData blackboardData = new();
-
+        [TextArea(1,10)]
         [SerializeField]
-        [TextArea]
         //[HideInInspector]
         private string jsonObject;
-
+        [TextArea(1,10)]
+        [SerializeField]
+        private string jsonBlackboard;
         public void OnBeforeSerialize(){
-            var serializedData  = JsonConvert.SerializeObject(NodeDictionary,JsonSerializeTool.JsonSerializerSettings);
+            jsonObject = JsonConvert.SerializeObject(NodeDictionary,JsonSerializeTool.JsonSerializerSettings);
-       
+            jsonBlackboard = JsonConvert.SerializeObject(blackboardData,JsonSerializeTool.JsonSerializerSettings);
-            jsonObject = serializedData;
         }
-
         public void OnAfterDeserialize(){
+            //Deserialize node dictionary
             var deserializedData = JsonConvert.DeserializeObject<Dictionary<string,NodeData>>(jsonObject,JsonSerializeTool.JsonSerializerSettings);
-            var deserializedData2 = JsonUtility.FromJson<Dictionary<string,NodeData>>(jsonObject);
             NodeDictionary = deserializedData;
+            //Deserialize blackboard data
+            var deserializedBlackboard = JsonConvert.DeserializeObject<BlackboardData>(jsonBlackboard,JsonSerializeTool.JsonSerializerSettings);
+            blackboardData = deserializedBlackboard;
+            
             Debug.Log("hi");
         }
     }

TNode/Models/NodeData.cs

@@ -21,6 +21,12 @@ namespace TNode.Models{
         public string id;
         public string nodeName;
         public bool entryPoint;
+
+
+        public virtual void OnProcess(){
+            
+        }
+        
 // #if UNITY_EDITOR
 //         public Rect rect;
 // #endif

TNode/Runtime/RuntimeGraph.cs

@@ -1,9 +1,28 @@
-using TNode.Models;
+using System.Collections;
+using System.Collections.Generic;
+using TNode.Models;
 using UnityEngine;
 
 namespace TNode.Runtime{
     public class RuntimeGraph:MonoBehaviour{
         public GraphData graphData;
+        public SortedSet<RuntimeNode> _sortedSet;
 
+        public void Start(){
+            //iterate through all nodes and add them to the sorted set
+            foreach (var node in graphData.NodeDictionary.Values){
+                
+            }
+        }
+        
+        public void StartProcessNode(ProcessingStrategy strategy, RuntimeNode entry){
+            
+        }
+        
+    }
+
+    public enum ProcessingStrategy{
+        BreadthFirst,
+        DepthFirst
     }
 }

TNode/Runtime/RuntimeNode.cs

@@ -5,17 +5,11 @@ using System.Linq;
 using TNode.Models;
 
 namespace TNode.Runtime{
-    public class RuntimeNode<T> where T:NodeData{
+    public abstract class RuntimeNode{
-        public T NodeData{ get; set; }
+        public NodeData NodeData;
-
-        //Links related to runtime node,for fast access.only remember out links
         public List<NodeLink> NodeLinks;
-
+        public void ProcessThisNode(){
-
+            NodeData.OnProcess();
-        public void Process(){
-      
-            var outputPorts = NodeLinks.Select(x => x.outPort.portName);
         }
- 
     }
 }

TNode/RuntimeCache/RuntimeCache.cs

@@ -34,13 +34,18 @@ namespace TNode.RuntimeCache{
             var type = typeof(T);
             if(!CachedDelegatesForGettingValue.ContainsKey(type)){
                 CachedDelegatesForGettingValue.Add(type, new List<GetValueDelegate>());
-            }
-            //iterate properties of the nodeData and add them to the cache
                 var properties = type.GetProperties();
                 foreach(var property in properties){
                     var getValueDelegate = GetValueDelegateForProperty(property);
                     CachedDelegatesForGettingValue[type].Add(getValueDelegate);
                 }
+            }
+            else{
+                //Cache already exists for this type
+                
+            }
+       
+    
             
         }