public void Initialize() { if (!Application.isPlaying) { throw new System.Exception("Can't initialize when the aplication is not playing."); } if (target == null) { throw new System.Exception("Target graph can't be null"); } var type = target.GeneratedTypeName.ToType(false); if (type != null) { runtimeAsset = ScriptableObject.CreateInstance(type) as RuntimeAsset; for (int i = 0; i < target.Variables.Count; i++) { VariableData var = target.Variables[i]; for (int x = 0; x < variable.Count; x++) { if (var.Name.Equals(variable[x].Name)) { SetVariable(var.Name, variable[x].value); } } } } else { var mainObject = new GameObject(name); mainObject.SetActive(false); uNodeRoot graph = Instantiate(target); uNodeRuntime main = mainObject.AddComponent <uNodeRuntime>(); main.originalGraph = target; main.Name = target.GraphName; main.Variables = graph.Variables; main.RootObject = graph.RootObject; main.RootObject.transform.SetParent(mainObject.transform); AnalizerUtility.RetargetNodeOwner(graph, main, main.RootObject.GetComponentsInChildren <MonoBehaviour>(true)); main.Refresh(); Destroy(graph.gameObject); for (int i = 0; i < main.Variables.Count; i++) { VariableData var = main.Variables[i]; for (int x = 0; x < variable.Count; x++) { if (var.Name.Equals(variable[x].Name)) { main.Variables[i] = new VariableData(variable[x]); } } } //Uncomment this to prevent resetting variable you're exiting play mode // this.variable = main.variable; this.runtimeInstance = main; GameObject.DontDestroyOnLoad(mainObject); } }
/// <summary> /// Retarget node owner. /// </summary> /// <param name="fromOwner"></param> /// <param name="toOwner"></param> /// <param name="nodes"></param> public static void RetargetNodeOwner(uNodeRoot fromOwner, uNodeRoot toOwner, IList <MonoBehaviour> nodes, Action <object> valueAction = null) { Object[] from = new Object[] { fromOwner, fromOwner.transform, fromOwner.gameObject }; Object[] to = new Object[] { toOwner, toOwner.transform, toOwner.gameObject }; foreach (var behavior in nodes) { if (behavior is Node) { Node node = behavior as Node; node.owner = toOwner; } else if (behavior is RootObject) { RootObject root = behavior as RootObject; root.owner = toOwner; } AnalizeObject(behavior, (obj) => { if (valueAction != null) { valueAction(obj); } if (obj is MemberData) { MemberData data = obj as MemberData; data.RefactorUnityObject(from, to); //return true; } return(false); }, (instance, field, type, value) => { Object o = value as Object; if (o) { if (o == fromOwner) { field.SetValueOptimized(instance, toOwner); } else if (o == from[1]) { field.SetValueOptimized(instance, to[1]); } else if (o == from[2]) { field.SetValueOptimized(instance, to[2]); } } }); } }
public static uNodeRuntime InstantiateGraph(uNodeRoot targetGraph, GameObject destination, IList <VariableData> variables) { try { var data = GetCachedGraph(targetGraph); uNodeRuntime main = destination.AddComponent <uNodeRuntime>(); data.retargetAction?.Invoke(main); //This will retarget the node owner to the new owner var graph = Object.Instantiate(data.graph); //Instantiate the cached graph main.originalGraph = targetGraph; //Assign the original graph main.Name = targetGraph.GraphName; //This will ensure the uid is valid var defaultVariable = graph.Variables; main.RootObject = graph.RootObject; main.RootObject.transform.SetParent(destination.transform); Object.Destroy(graph.gameObject); //Clean up cached graph main.Refresh(); //Refresh the graph so it has up to date data #if !UNODE_DEBUG_PLUS main.hideFlags = HideFlags.HideInInspector; //Ensure the graph doesn't show up in the inspector #else main.RootObject.hideFlags = HideFlags.None; #endif //Initialize variable values main.Variables = defaultVariable; //This is for set variable value to be same with the graph if (variables != null) //This is for set variable value to same with overridden variable in instanced graph { for (int i = 0; i < main.Variables.Count; i++) { VariableData var = main.Variables[i]; for (int x = 0; x < variables.Count; x++) { if (var.Name.Equals(variables[x].Name)) { main.Variables[i] = variables[x]; } } } } return(main); } catch (Exception ex) { Debug.LogError($"Error on trying to initialize graph: {targetGraph.GraphName} to the {destination}.\nError: {ex.ToString()}", targetGraph); throw; } }
static RuntimeGraphData GetCachedGraph(uNodeRoot targetGraph) { RuntimeGraphData graphData; if (!runtimeGraphMap.TryGetValue(targetGraph, out graphData)) { uNodeRoot graph = Object.Instantiate(targetGraph); //Begin instantiate original graph graph.gameObject.name = targetGraph.gameObject.name; //Ensure the cached graph name is same with the original graph #if !UNODE_DEBUG graph.gameObject.hideFlags = HideFlags.HideInHierarchy; //Ensure the cached graph doesn't show in the hierarchy #endif Object.DontDestroyOnLoad(graph.gameObject); //Ensure this cached graph is cached across scenes graphData = new RuntimeGraphData() { graph = graph, originalGraph = targetGraph, retargetAction = AnalizerUtility.GetRetargetNodeOwnerAction(graph, graph.RootObject.GetComponentsInChildren <MonoBehaviour>(true)), }; runtimeGraphMap[targetGraph] = graphData; } return(graphData); }
/// <summary> /// Get retarget node Action /// </summary> /// <param name="graph"></param> /// <param name="nodes"></param> /// <returns></returns> public static Action <uNodeRoot> GetRetargetNodeOwnerAction(uNodeRoot graph, IList <MonoBehaviour> nodes) { Action <uNodeRoot> action = null; var fromTR = graph.transform; var fromGO = graph.gameObject; var from = new Object[] { graph, fromTR, fromGO }; foreach (var behavior in nodes) { if (behavior is Node) { Node node = behavior as Node; action += (owner) => { node.owner = owner; }; } else if (behavior is RootObject) { RootObject root = behavior as RootObject; action += (owner) => { root.owner = owner; }; } AnalizeObject(behavior, (obj) => { if (obj is MemberData) { MemberData data = obj as MemberData; if (data.instanceReference != null) { for (int i = 0; i < data.instanceReference.Count; i++) { Object o = data.instanceReference[i]; int index = i; if (o == graph) { action += (owner) => { data.instanceReference[index] = owner; }; } else if (o == fromTR) { action += (owner) => { data.instanceReference[index] = owner.transform; }; } else if (o == fromGO) { action += (owner) => { data.instanceReference[index] = owner.gameObject; }; } } } if (data.targetReference != null) { for (int i = 0; i < data.targetReference.Count; i++) { Object o = data.targetReference[i]; int index = i; if (o == graph) { action += (owner) => { data.targetReference[index] = owner; }; } else if (o == fromTR) { action += (owner) => { data.targetReference[index] = owner.transform; }; } else if (o == fromGO) { action += (owner) => { data.targetReference[index] = owner.gameObject; }; } } } if (data.typeReference != null) { for (int i = 0; i < data.typeReference.Count; i++) { Object o = data.typeReference[i]; int index = i; if (o == graph) { action += (owner) => { data.typeReference[index] = owner; }; } else if (o == fromTR) { action += (owner) => { data.typeReference[index] = owner.transform; }; } else if (o == fromGO) { action += (owner) => { data.typeReference[index] = owner.gameObject; }; } } } if (data.odinTargetData.references != null) { for (int i = 0; i < data.odinTargetData.references.Count; i++) { Object o = data.odinTargetData.references[i]; int index = i; if (o == graph) { action += (owner) => { data.odinTargetData.references[index] = owner; }; } else if (o == fromTR) { action += (owner) => { data.odinTargetData.references[index] = owner.transform; }; } else if (o == fromGO) { action += (owner) => { data.odinTargetData.references[index] = owner.gameObject; }; } } } if (data.odinInstanceData.references != null) { for (int i = 0; i < data.odinInstanceData.references.Count; i++) { Object o = data.odinInstanceData.references[i]; int index = i; if (o == graph) { action += (owner) => { data.odinInstanceData.references[index] = owner; }; } else if (o == fromTR) { action += (owner) => { data.odinInstanceData.references[index] = owner.transform; }; } else if (o == fromGO) { action += (owner) => { data.odinInstanceData.references[index] = owner.gameObject; }; } } } //if(data.HasUnityReference(from)) { // var act = data.GetActionForRefactorUnityObject(from); // action += (owner) => { // act(new Object[] { owner, owner.transform, owner.gameObject }); // }; //} //return true; } return(false); }, (instance, field, type, value) => { Object o = value as Object; if (o) { if (o == graph) { action += (owner) => { field.SetValueOptimized(instance, owner); }; } else if (o == fromTR) { action += (owner) => { field.SetValueOptimized(instance, owner.transform); }; } else if (o == fromGO) { action += (owner) => { field.SetValueOptimized(instance, owner.gameObject); }; } } }); } return(action); }
public RuntimeGraphType(uNodeRoot target) { this.target = target; }