1.stage 1 complete ,now NodeData are fully serializable!

Dialogue.meta

@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 95903e6a18543fb46ba6bd05887b9e85
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Sample/HelloComponent.cs

@@ -0,0 +1,13 @@
+using System;
+using UnityEngine;
+
+namespace Sample{
+    public class HelloComponent:MonoBehaviour{
+        public void Update(){
+            var trans1 = gameObject.transform;
+            var trans2 = gameObject.GetComponent<Transform>();
+            var tran3 = GetComponent<Transform>();
+            var tran4 = transform;
+        }
+    }
+}

Sample/HelloComponent.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: aba7d5b338ab470aa820882d309d1f7c
+timeCreated: 1656587766

Sample/HelloNode.cs

@@ -1,9 +1,11 @@
 using TNode.Attribute;
 using TNode.Models;
+using UnityEngine;
 
 namespace Sample{
     [GraphUsage(typeof(HelloGraph))]
     public class HelloNode:NodeData{
-        
+        [ShowInNodeView]
+        public string SayHelloText = "";
     }
 }

TNode/Editor/BaseViews/NodeView.cs

@@ -16,11 +16,20 @@ namespace TNode.Editor.BaseViews{
         public T Data{
             get => _data;
             set{
+                if(_data!=null)
+                    ((NodeDataWrapper)_data).OnValueChanged -= OnDataValueChanged;
                 _data = value;
                 OnDataChanged?.Invoke(value);
+                if(_data!=null)
+                    ((NodeDataWrapper)_data).OnValueChanged += OnDataValueChanged;
    
             }
         }
+
+        private void OnDataValueChanged(NodeDataWrapper obj){
+            Refresh();
+        }
+
         public sealed override string title{
             get => base.title;
             set => base.title = value;
@@ -29,13 +38,11 @@ namespace TNode.Editor.BaseViews{
 
         protected NodeView(){
             OnDataChanged+=OnDataChangedHandler;
-
             _nodeInspectorInNode = new NodeInspectorInNode(){
                 name = "nodeInspectorInNode"
             };
             this.extensionContainer.Add(_nodeInspectorInNode);
         }
-
         private void OnDataChangedHandler(T obj){
             this.title = _data.nodeName;
             if (_nodeInspectorInNode != null){
@@ -60,9 +67,7 @@ namespace TNode.Editor.BaseViews{
 
         public void Refresh(){
             title = _data.nodeName;
-            
         }
-
     }
 
     public interface INodeView{

TNode/Editor/Inspector/InspectorItem.cs

@@ -1,21 +1,22 @@
-using TNode.BaseViews;
+using System;
+using TNode.BaseViews;
 using TNode.Models;
 using UnityEngine;
 using UnityEngine.UIElements;
 
 namespace TNode.Editor.Inspector{
-    public abstract class InspectorItem<T>:VisualElement,INodeDataBinding<T>{
+    public abstract class InspectorItem<T>:VisualElement,INodeDataBinding<T> {
         private NodeData _bindingNodeData;
         private string _bindingFieldName;
         protected BaseField<T> Bindable;
-        protected event System.Action OnValueChanged;
+        protected event System.Action OnDataChanged;
 
         public string BindingPath{
             get => _bindingFieldName;
             set{
                 _bindingFieldName = value;
                 if(_bindingFieldName!=null&&_bindingNodeData!=null){
-                    OnValueChanged?.Invoke();
+                    OnDataChanged?.Invoke();
                 }
             }
         }
@@ -23,19 +24,22 @@ namespace TNode.Editor.Inspector{
         public NodeData BindingNodeData{
             get => _bindingNodeData;
             set{
+                var oldWrapper = ((NodeDataWrapper) _bindingNodeData);
+                if(oldWrapper!=null){
+                    oldWrapper.OnValueChanged -= OnNodeDataValueChanged;
+                }
                 _bindingNodeData = value;
                 if(_bindingFieldName!=null&&_bindingNodeData!=null){
-                    OnValueChanged?.Invoke();
+                    OnDataChanged?.Invoke();
                 }
-                
+                if(_bindingNodeData!=null)
+                    ((NodeDataWrapper) _bindingNodeData).OnValueChanged += OnNodeDataValueChanged;
             }
         }
 
         private T GetValue(){
         
             var fieldInfo = _bindingNodeData.GetType().GetField(BindingPath, System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance);
-            Debug.Log(fieldInfo);
-            Debug.Log(fieldInfo?.FieldType );
             //check field type
             if (fieldInfo != null && fieldInfo.FieldType == typeof(T)){
                 return (T)fieldInfo.GetValue(BindingNodeData);
@@ -49,41 +53,49 @@ namespace TNode.Editor.Inspector{
         protected T Value => GetValue();
 
         protected void SetValue(T value){
-            var fieldInfo = _bindingNodeData.GetType().GetField(BindingPath, System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance);
-            Debug.Log(fieldInfo);
-            Debug.Log(fieldInfo?.FieldType );
-            if (fieldInfo != null && fieldInfo.FieldType == typeof(T)){
-                fieldInfo.SetValue(_bindingNodeData,value);
-                
-                //if value changed ,notify node inspector's current inspecting node view
-                if (parent.parent is NodeInspector nodeInspector){
-                    nodeInspector.NodeView.OnDataModified();
+            NodeDataWrapper wrapper = _bindingNodeData;
+            Debug.Log(wrapper);
+            wrapper.SetValue(BindingPath,value);
         }
+        public  InspectorItem(){
+           
+            OnDataChanged+= OnDataChangedHandler;
         }
-            else{
-                Debug.LogError("Wrong Type for current node data");
+        /*
+         *      e => {
+            SetValue(e.newValue);
         }
+         */
+        private void OnInspectorItemValueChanged(ChangeEvent<T> e){
+            SetValue(e.newValue);
         }
-        public  InspectorItem(){
 
-            OnValueChanged+= OnValueChangedHandler;
-        }
         public void CreateBindable(BaseField<T> bindable){
+            if (Bindable != null){
+                Bindable.Clear();
+                Bindable.UnregisterValueChangedCallback(OnInspectorItemValueChanged);
+            }
             Bindable = bindable;
             this.Add(Bindable);
-            Bindable?.RegisterValueChangedCallback(e => {
-                SetValue(e.newValue);
-            });
+            Bindable?.RegisterValueChangedCallback(OnInspectorItemValueChanged);
         }
-        private void OnValueChangedHandler(){
+        private void OnDataChangedHandler(){
             Bindable = this.Q<BaseField<T>>();
             if(Bindable!= null){
                 Bindable.value = Value;
                 Bindable.label = BindingPath;
             }
         }
+
+        private  void OnNodeDataValueChanged(NodeDataWrapper wrapper){
+            var value = (T) wrapper.GetValue(BindingPath) ;
+            if(Bindable!=null){
+                Bindable.value = value;
+            }
+        }
+
         ~InspectorItem(){
-            OnValueChanged-= OnValueChangedHandler;
+            OnDataChanged-= OnDataChangedHandler;
         }
     }
 }

TNode/Editor/Inspector/InspectorItemFactory.cs

@@ -12,8 +12,6 @@ namespace TNode.Editor.Inspector{
         public InspectorItem<T> Create<T>(){
             //Check type of GraphDataType
             var hasSpecificType = NodeEditorExtensions.HasSpecificType<InspectorItem<T>>();
-            Debug.Log(typeof(InspectorItem<T>));
-            Debug.Log(hasSpecificType);
             if (hasSpecificType){
                 return NodeEditorExtensions.CreateInstance<InspectorItem<T>>();
             }

TNode/Editor/NodeDataWrapper.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using TNode.Models;
+
+namespace TNode.Editor{
+    public class NodeDataWrapper{
+        private readonly NodeData _data;
+        private static readonly Dictionary<NodeData,NodeDataWrapper> Cache = new ();
+        public event Action<NodeDataWrapper> OnValueChanged;
+        public static NodeDataWrapper Get(NodeData data){
+            if(Cache.ContainsKey(data)){
+                return Cache[data];
+            }
+            var wrapper = new NodeDataWrapper(data);
+            Cache.Add(data,wrapper);
+            return wrapper;
+        }
+        public NodeDataWrapper(NodeData data){
+            this._data = data;
+        }
+      
+        public void SetValue(string path, object value){
+            var fieldInfo = _data.GetType().GetField(path);
+            fieldInfo.SetValue(_data,value);
+            OnValueChanged?.Invoke(this);
+        }
+
+        public object GetValue(string path){
+            var fieldInfo = _data.GetType().GetField(path);
+            return fieldInfo.GetValue(_data);
+        }
+        public static implicit operator NodeData(NodeDataWrapper wrapper){
+            if (wrapper == null)
+                return null;
+            return wrapper._data;
+        }
+        public static implicit operator NodeDataWrapper(NodeData unWrapper){
+            if (unWrapper == null)
+                return null;
+            return Get(unWrapper);
+        }
+
+    }
+}

TNode/Editor/NodeDataWrapper.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 70538db48fe1494882ba207e1b3be19d
+timeCreated: 1656585993

TNode/Models/GraphData.cs

@@ -1,7 +1,5 @@
 using System;
 using System.Collections.Generic;
-using Dialogue;
-using UnityEditor.Experimental.GraphView;
 using UnityEngine;
 
 namespace TNode.Models{

TNode/Models/NodeLink.cs

@@ -1,30 +1,11 @@
 using System;
-using Dialogue;
+
 
 namespace TNode.Models{
     //NodeAttribute links are stored in output side of the two node port.
     [Serializable]
     public class NodeLink{
        // public DialogueNodePortData From{ get; }
-        public bool ConditionEdge = false;
-        public DialogueNodePortData To{ get; }
-        public NodeLink(DialogueNodePortData  to){
-           // From = from;
-            To = to;
-        }
-        public delegate bool Condition(DialogueNodePortData to);
-        public Condition ConditionFunction;
    
-        public bool Accessible{
-            get{
-                if (To == null) return false;
-                if(ConditionFunction == null)
-                    return true;
-                return ConditionFunction(To);
-            }
-        }
-        public void SetCondition(Condition condition){
-            ConditionFunction = condition;
-        }
     }
 }