internal static FREditorSettings GetOrCreateSettings() { var _found = AssetDatabase.FindAssets(string.Format("t:" + typeof(FREditorSettings).Name)); FREditorSettings settings = null; if (_found.Length > 0) { var assetPath = AssetDatabase.GUIDToAssetPath(_found[0]); settings = AssetDatabase.LoadAssetAtPath <FREditorSettings>(assetPath); if (settings.graphWindows == null) { settings.graphWindows = new List <GraphWindows>(); } } else { var _path = "Assets/FlowReactorSettings.asset"; //Path.Combine(EditorHelpers.GetRelativeSettingsPath(), "FlowReactorSettings.asset"); settings = ScriptableObject.CreateInstance <FREditorSettings>(); settings.ResetColors(); settings.ResetShortcuts(); settings.graphWindows = new List <GraphWindows>(); AssetDatabase.CreateAsset(settings, _path); AssetDatabase.SaveAssets(); //Debug.Log("reset settings"); } return(settings); }
public override void OnInspectorGUI() { using (new GUILayout.HorizontalScope("Box")) { GUILayout.Label(logo); } if (GUILayout.Button("Edit", GUILayout.Height(40))) { //GraphEditor window = null; //var _settings = (FREditorSettings)FREditorSettings.GetOrCreateSettings(); //if (_settings.graphWindows.TryGetValue(graph.GetInstanceID(), out window)) //{ // window.Init(window, graph); // window.Focus(); //} //else //{ // window = CreateInstance<GraphEditor>(); // _settings.graphWindows.Add(graph.GetInstanceID(), window); // window.Init(window, graph); //} var _settings = (FREditorSettings)FREditorSettings.GetOrCreateSettings(); _settings.OpenGraphWindow(graph); } // DEBUG #if FLOWREACTOR_DEBUG DrawDefaultInspector(); #endif }
static void GetAvailableColors() { settings = (FREditorSettings)FREditorSettings.GetSerializedSettings().targetObject as FREditorSettings; availableColors = new Dictionary <string, Color>(); if (EditorGUIUtility.isProSkin) { for (int d = 0; d < settings.defaultColorsDark.Count; d++) { availableColors.Add(settings.defaultColorsDark[d].id, settings.defaultColorsDark[d].color); } } else { for (int d = 0; d < settings.defaultColorsLight.Count; d++) { availableColors.Add(settings.defaultColorsLight[d].id, settings.defaultColorsLight[d].color); } } for (int c = 0; c < settings.categoryColors.Count; c++) { availableColors.Add(settings.categoryColors[c].id, settings.categoryColors[c].color); } whiteBox = EditorHelpers.LoadGraphic("whiteBox.png"); }
public void ReloadColors(FlowReactor.Editor.FREditorSettings _settings) { for (int n = 0; n < nodes.Count; n++) { nodes[n].ReloadColor(_settings); } for (int s = 0; s < subGraphs.Count; s++) { subGraphs[s].ReloadColors(_settings); } }
public NodePanel(Rect _rect, Graph _graph, GraphEditor _graphEditor, GUISkin _editorSkin, FREditorSettings _settings) { firstNodeName = ""; current = this; //collectedNodes = _collectedNodes; rect = _rect; position = new Vector2(rect.x, rect.y); graph = _graph; graphEditor = _graphEditor; editorSkin = _editorSkin; settings = _settings; }
IEnumerator UpdateFavouritesIE() { collectedNodes.categories.Remove("Favorites"); var _settings = (FREditorSettings)FREditorSettings.GetOrCreateSettings(); List <CollectAvailableNodes.CollectedNodesData> coll = new List <CollectAvailableNodes.CollectedNodesData>(); for (int f = 0; f < _settings.favoredNodes.Count; f++) { coll.Insert(0, new CollectAvailableNodes.CollectedNodesData ( //_settings.favoredNodes[f].name, _settings.favoredNodes[f].title, _settings.favoredNodes[f].typeName, _settings.favoredNodes[f].nameSpace, "Favorites", _settings.favoredNodes[f].description, _settings.favoredNodes[f].color, _settings.favoredNodes[f].outputSlotCount, _settings.favoredNodes[f].nodeOutputs, _settings.favoredNodes[f].nodeType )); } for (int c = 0; c < coll.Count; c++) { var _child = collectedNodes.BuildTree(coll[c].category, coll[c].name); _child.AddNode ( //coll[c].name, coll[c].title, coll[c].typeName, coll[c].nameSpace, coll[c].category, coll[c].description, coll[c].color, coll[c].outputCount, coll[c].nodeOutputs, coll[c].nodeType ); } yield return(new WaitForSeconds(0.2f)); stopTraversing = false; }
static void UpdateSettings() { // Get current settings var _tmpSettings = (FREditorSettings)FREditorSettings.GetSerializedSettings().targetObject as FREditorSettings; if (_tmpSettings.version != EditorHelpers.GetEditorVersion()) { // get new settings var _newSettings = ScriptableObject.CreateInstance <FREditorSettings>(); _newSettings.ResetColors(); _newSettings.ResetShortcuts(); // Compare default colors if (_tmpSettings.defaultColorsDark.Count != _newSettings.defaultColorsDark.Count) { for (int d = 0; d < _newSettings.defaultColorsDark.Count; d++) { var _exists = false; for (int e = 0; e < _tmpSettings.defaultColorsDark.Count; e++) { if (_tmpSettings.defaultColorsDark[e].id == _newSettings.defaultColorsDark[d].id) { _exists = true; } } if (!_exists) { _tmpSettings.defaultColorsDark.Add(_newSettings.defaultColorsDark[d]); _tmpSettings.defaultColorsLight.Add(_newSettings.defaultColorsLight[d]); } } } if (_tmpSettings.inspectorColors == null || _tmpSettings.inspectorColors.Count == 0) { _tmpSettings.inspectorColors = new List <EditorColors>() { new EditorColors("inspectorColor", new Color(165f / 255f, 140f / 255f, 205f / 255, 255f / 255f)), new EditorColors("blackboardColor", Color.black), new EditorColors("eventboardColor", new Color(120f / 255f, 195f / 255f, 255f / 255, 255f / 255f)), }; } _tmpSettings.version = EditorHelpers.GetEditorVersion(); } }
//[UnityEditor.Callbacks.DidReloadScripts] static void ShowChangelogAfterCompilation() { if (settings == null) { settings = FREditorSettings.GetOrCreateSettings(); } var _newVersion = EditorHelpers.GetEditorVersion(); if (settings.version != _newVersion) { settings.version = _newVersion; FlowReactorChangelogWindow.Init(); } }
public static bool OpenGraph(int instanceID, int line) { object _obj = EditorUtility.InstanceIDToObject(instanceID); var _graph = _obj as Graph; if (_graph != null) { //var window = CreateInstance<GraphEditor>(); //window.Init(window, _graph); var _settings = (FREditorSettings)FREditorSettings.GetOrCreateSettings(); _settings.OpenGraphWindow(_graph); return(true); } else { return(false); } }
static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths) { var _settings = FREditorSettings.GetOrCreateSettings(); _settings.errorReport = ""; //foreach (string str in importedAssets) //{ // Debug.Log("Reimported Asset: " + str); //} foreach (string str in deletedAssets) { _settings.errorReport += "deleted file: " + str + "\n"; } for (int i = 0; i < movedAssets.Length; i++) { _settings.errorReport += "old file: " + movedFromAssetPaths[i] + " new file: " + movedAssets[i] + "\n"; } }
public static SettingsProvider CreateMyCustomSettingsProvider() { // First parameter is the path in the Settings window. // Second parameter is the scope of this setting: it only appears in the Project Settings window. var provider = new SettingsProvider("FREditorSettings", SettingsScope.User) { // By default the last token of the path is used as display name if no label is provided. label = "FlowReactor", // Create the SettingsProvider and initialize its drawing (IMGUI) function in place: guiHandler = (searchContext) => { var settings = (FREditorSettings)FREditorSettings.GetSerializedSettings().targetObject as FREditorSettings; FREditorSettingsGUI.Draw(settings); }, // Populate the search keywords to enable smart search filtering and label highlighting: keywords = new HashSet <string>(new[] { "FlowReactor" }) }; return(provider); }
public static Node CreateNode(NodeCategoryTree.NodeData _nodeData, Graph _rootGraph, Graph _graphOwner, string _type, Vector2 _position, bool _isCopy) { if (_nodeData == null) { allNodes = CollectAvailableNodes.CollectNodes(); _nodeData = allNodes.GetData(_type); } Node node = Node.CreateNode(_type, _nodeData.typeName); // Assign attributes to node node.outputNodes = new List <Node.NodeOutput>(); //(_nodeAttributes.outputSlotCount); if (_nodeData.outputSlotCount > -1) { for (int i = 0; i < _nodeData.outputSlotCount; i++) { node.outputNodes.Add(new Node.NodeOutput()); } } if (_nodeData.nodeOutputs != null) { for (int i = 0; i < _nodeData.nodeOutputs.Length; i++) { node.outputNodes.Add(new Node.NodeOutput(_nodeData.nodeOutputs[i])); } } //_position = new Vector2(_position.x / _rootGraph.zoomFactor, _position.y / _rootGraph.zoomFactor); node.inputNodes = new List <Node.InputNode>(); node.nodeRect = new Rect(_position.x, _position.y, node.nodeRect.width, node.nodeRect.height); // Get settings var _editorSettings = (FREditorSettings)FREditorSettings.GetSerializedSettings().targetObject as FREditorSettings; node.color = _editorSettings.GetColor(_nodeData.color); node.nodeData = _nodeData; node.isCopy = _isCopy; node.guid = Guid.NewGuid().ToString(); _graphOwner.AddNode(node); node.rootGraph = _rootGraph; node.graphOwner = _graphOwner; //node.nodeStringType = _type; if (!_isCopy) { node.Init(_rootGraph, node); // _graphOwner.nodes.Count, node); } if (node.outputNodes.Count > 1) { node.nodeRect.height += (node.outputNodes.Count - 1) * 20; } node.SetupVariables(); // check if newly created node has been created inside a group // if true, add new node to this group for (int n = 0; n < _rootGraph.currentGraph.nodes.Count; n++) { if (_rootGraph.currentGraph.nodes[n].nodeData.nodeType == NodeAttributes.NodeType.Group && _rootGraph.currentGraph.nodes[n] != node && _rootGraph.currentGraph.nodes[n].nodeRect.Contains(new Vector2(node.nodeRect.x, node.nodeRect.y))) { var _g = _rootGraph.currentGraph.nodes[n] as Group; _g.AddNodeToGroup(node); } } EditorUtility.SetDirty(node); EditorUtility.SetDirty(_rootGraph); node.lastZoomCoordsOrigin = _rootGraph.currentGraph.zoomCoordsOrigin; // Better than AssetDatabase SaveAsset or Refresh for refreshing node Undo.SetCurrentGroupName("Create Node"); int undoGroup = Undo.GetCurrentGroup(); Undo.RecordObject(node, "Create Node"); Undo.CollapseUndoOperations(undoGroup); return(node); }
public static NodeCategoryTree CollectNodes() { collectedNodes = new NodeCategoryTree(); var _found = System.AppDomain.CurrentDomain.FlowReactorGetAllDerivedTypes(typeof(Node)); //System.Type[] _types = System.Reflection.Assembly.GetExecutingAssembly().GetTypes(); //System.Type[] _found = (from System.Type type in _types where type.IsSubclassOf(typeof(Node)) select type).ToArray(); List <CollectedNodesData> collected = new List <CollectedNodesData>(); for (int i = 0; i < _found.Length; i++) { NodeAttributes _nodeAttributes = System.Attribute.GetCustomAttribute(_found[i], typeof(NodeAttributes)) as NodeAttributes; if (_nodeAttributes != null) { collected.Add(new CollectedNodesData( _found[i].Name.ToString(), // Title _found[i].Name.ToString(), // type name _found[i].Namespace, _nodeAttributes.category, _nodeAttributes.description, _nodeAttributes.color, _nodeAttributes.outputSlotCount, _nodeAttributes.nodeOutputs, _nodeAttributes.nodeType)); } } // Sort by categories collected = collected.OrderBy(c => c.category).ToList(); // Add favorit nodes var _settings = (FREditorSettings)FREditorSettings.GetOrCreateSettings(); if (_settings.favoredNodes == null) { _settings.favoredNodes = new List <NodeCategoryTree.NodeData>(); } for (int f = 0; f < _settings.favoredNodes.Count; f++) { collected.Insert(0, new CollectedNodesData ( //_settings.favoredNodes[f].name, _settings.favoredNodes[f].title, _settings.favoredNodes[f].typeName, _settings.favoredNodes[f].nameSpace, "Favorites", _settings.favoredNodes[f].description, _settings.favoredNodes[f].color, _settings.favoredNodes[f].outputSlotCount, _settings.favoredNodes[f].nodeOutputs, _settings.favoredNodes[f].nodeType )); } for (int c = 0; c < collected.Count; c++) { var _child = collectedNodes.BuildTree(collected[c].category, collected[c].name); _child.AddNode ( //collected[c].name, collected[c].title, collected[c].typeName, collected[c].nameSpace, collected[c].category, collected[c].description, collected[c].color, collected[c].outputCount, collected[c].nodeOutputs, collected[c].nodeType ); } return(collectedNodes); }
public override void OnInspectorGUI() { if (editorSkin == null) { editorSkin = EditorHelpers.LoadSkin(); editIcon = EditorHelpers.LoadIcon("editIcon.png"); refreshIcon = EditorHelpers.LoadIcon("refreshIcon.png"); okIcon = EditorHelpers.LoadIcon("checkmarkIcon.png"); cancelIcon = EditorHelpers.LoadIcon("cancelIcon.png"); } if (fr != null && fr.graph != null) { GUI.enabled = true; } else { GUI.enabled = false; } using (new GUILayout.HorizontalScope("Box")) { if (GUILayout.Button((Application.isPlaying && fr.runUniqueInstance) ? "Open instance" : "Open", GUILayout.Height(50))) { //var window = CreateInstance<GraphEditor>(); //window.Init(window, fr.graph); var _settings = (FREditorSettings)FREditorSettings.GetOrCreateSettings(); _settings.OpenGraphWindow(fr.graph); // Check if graph needs to be updated GraphUpdater.UpdateGraph(fr.graph); } if (Application.isPlaying && fr.runUniqueInstance) { if (GUILayout.Button("Open original", GUILayout.Height(50))) { //var window = CreateInstance<GraphEditor>(); //window.Init(window, fr.originalGraph); var _settings = (FREditorSettings)FREditorSettings.GetOrCreateSettings(); _settings.OpenGraphWindow(fr.originalGraph); } } } GUI.enabled = true; EditorGUI.BeginChangeCheck(); using (new GUILayout.HorizontalScope("Box")) { fr.graph = (Graph)EditorGUILayout.ObjectField(fr.graph, typeof(Graph), false); if (GUILayout.Button("New Graph")) { NodeCreator.CreateNewGraphWithDefaultNodes(fr); } } using (new GUILayout.VerticalScope(("Box"))) { using (new GUILayout.HorizontalScope()) { GUILayout.Label("Graph settings"); GUILayout.FlexibleSpace(); if (GUILayout.Button("?", GUILayout.Width(18))) { Application.OpenURL("https://flowreactor.io/documentation/flowreactor-component/"); } } fr.runUniqueInstance = GUILayout.Toggle(fr.runUniqueInstance, "unique instance"); fr.useGlobalUpdateLoop = GUILayout.Toggle(fr.useGlobalUpdateLoop, "global update loop"); } if (fr.graph == null) { return; } // cache keys which needs to be removed List <string> cleanupKeys = new List <string>(); EditorHelpers.DrawUILine(); #region nodecontrollables // NODE CONTROLLABLES //////////////////////////// using (new GUILayout.HorizontalScope("Toolbar")) { GUILayout.Label("Node controlled objects", "boldLabel"); GUILayout.FlexibleSpace(); if (GUILayout.Button(new GUIContent(refreshIcon, "Collect all controllable nodes"), "toolbarButton")) { fr.graph.RegisterINodeControllables(fr); UpdateControllablesDictionary(); } if (GUILayout.Button("?", "toolbarButton")) { Application.OpenURL("https://flowreactor.io/documentation/frnodemodules/"); } } if (fr.nodeControllables != null && fr.nodeControllables.Count > 0) { EditorGUI.BeginChangeCheck(); using (new GUILayout.VerticalScope(editorSkin.GetStyle("BoxLine"))) { if (fr.nodeControllables != null) { foreach (Node node in fr.nodeControllables.Keys) { using (new GUILayout.VerticalScope("Box")) { using (new GUILayout.HorizontalScope("Toolbar")) { GUILayout.Label(node.nodeData.title); GUILayout.FlexibleSpace(); } Dictionary <string, INodeControllable> tempController = new Dictionary <string, INodeControllable>(); foreach (var faces in fr.nodeControllables[node].interfaces.Keys) { using (new GUILayout.HorizontalScope()) { GUILayout.Label(faces); var _lastRect = GUILayoutUtility.GetLastRect(); var _obj = EditorGUILayout.ObjectField((UnityEngine.Object)fr.nodeControllables[node].interfaces[faces], typeof(INodeControllable), true); if (GUILayout.Button("select")) { PopupWindow.Show(_lastRect, new PopupShowINodeControllableObjects(node, faces)); } //fr.gameControllerInterfaces[node].interfaces[faces] = _obj as INodeController; tempController.Add(faces, _obj as INodeControllable); } } foreach (var t in tempController.Keys) { fr.nodeControllables[node].interfaces[t] = tempController[t]; } } } } else { GUILayout.Label("null"); } } if (EditorGUI.EndChangeCheck()) { UnityEditor.SceneManagement.EditorSceneManager.MarkSceneDirty(UnityEditor.SceneManagement.EditorSceneManager.GetActiveScene()); } } EditorHelpers.DrawUILine(); //////////////////////////// #endregion #region exposedvariables // EXPOSED VARIABLES //////////////////////////// using (new GUILayout.HorizontalScope("Toolbar")) { GUILayout.Label("Exposed variables", "boldLabel"); GUILayout.FlexibleSpace(); if (GUILayout.Button(new GUIContent(refreshIcon, "Manually collect and update exposed variables from nodes"), "ToolbarButton")) { fr.CollectAndUpdateAllExposedVariables(); } #if FLOWREACTOR_DEBUG GUI.color = Color.yellow; if (GUILayout.Button("Clear exposed variables", "ToolbarButton")) { fr.exposedNodeVariables = new Dictionary <string, Dictionary <string, FRVariable> >(); fr.graph.exposedNodeVariables = new Dictionary <string, Graph.ExposedVariables>(); } GUI.color = Color.white; #endif } if (fr.exposedNodeVariables != null) { if (fr.exposedNodeVariables.Keys.Count > 0) { var i = 0; using (new GUILayout.VerticalScope(editorSkin.GetStyle("BoxLine"))) { foreach (string exposedNodeKey in fr.exposedNodeVariables.Keys) { if (EditorGUIUtility.isProSkin) { GUI.color = colorsDarkSkin[i % 2]; } else { GUI.color = colorsLighSkin[i % 2]; } using (new GUILayout.VerticalScope(editorSkin.GetStyle("BoxWhite"))) { GUI.color = Color.white; GUILayout.Label(exposedNodeKey, "boldLabel"); List <string> _variableKeys = fr.exposedNodeVariables[exposedNodeKey].Keys.ToList(); for (int s = 0; s < _variableKeys.Count; s++) { using (new GUILayout.HorizontalScope()) { var _variableKey = _variableKeys[s]; var _exposedVariable = fr.exposedNodeVariables[exposedNodeKey][_variableKey]; var _varType = _exposedVariable.GetType().Name.ToString(); GUILayout.Label(new GUIContent(_varType, "GetExposedVariable<" + _varType + ">(" + "\"" + exposedNodeKey + "\"," + "\"" + _variableKey + "\");"), GUILayout.Width(80)); GUI.enabled = _exposedVariable.editExposedName; _exposedVariable.exposedName = GUILayout.TextField(_exposedVariable.exposedName, GUILayout.Width(100)); GUI.enabled = true; if (_exposedVariable.editExposedName) { if (string.IsNullOrEmpty(_exposedVariable.exposedName)) { GUI.enabled = false; } if (GUILayout.Button(okIcon, GUILayout.Width(20), GUILayout.Height(20))) { _exposedVariable.editExposedName = false; var _fromName = _variableKey; var _newName = _exposedVariable.exposedName; #if FLOWREACTOR_DEBUG Debug.Log("update key from: " + _fromName + " to: " + _newName); #endif // check if new name already exists bool _nameAlreadyExists = false; foreach (var variableKeyB in fr.exposedNodeVariables[exposedNodeKey].Keys) { if (variableKeyB.Equals(_newName)) { _nameAlreadyExists = true; } } if (!_nameAlreadyExists) { var _nodeVariableField = fr.graph.exposedNodeVariables[exposedNodeKey].variables[_fromName].nodeOwner.GetType().GetField(fr.graph.exposedNodeVariables[exposedNodeKey].variables[_fromName].name); var _nodeVariable = _nodeVariableField.GetValue(fr.graph.exposedNodeVariables[exposedNodeKey].variables[_fromName].nodeOwner) as FRVariable; _nodeVariable.exposedName = _newName; fr.exposedNodeVariables[exposedNodeKey].UpdateKey(_fromName, _newName); fr.graph.exposedNodeVariables[exposedNodeKey].variables.UpdateKey(_fromName, _newName); } else { _exposedVariable.exposedName = _fromName; } } GUI.enabled = true; if (GUILayout.Button(cancelIcon, GUILayout.Width(20), GUILayout.Height(20))) { fr.exposedNodeVariables[exposedNodeKey][_variableKey].exposedName = _variableKey; fr.exposedNodeVariables[exposedNodeKey][_variableKey].editExposedName = false; } } else { if (GUILayout.Button(editIcon, GUILayout.Width(20), GUILayout.Height(20))) { fr.exposedNodeVariables[exposedNodeKey][_variableKey].editExposedName = true; } } if (fr.exposedNodeVariables[exposedNodeKey].ContainsKey(_variableKey)) { GUILayout.Label("Value: ", GUILayout.Width(50)); fr.exposedNodeVariables[exposedNodeKey][_variableKey].Draw(true, null); } //GUILayout.Label("Runtime access: GetData<" + fr.exposedNodeVariables[exposed].variables[variableKeys[s]].GetType().ToString() + ">("); } } } i++; } } } } //////////////////////////// #endregion #region sceneoverrides // BLACKBOARD SCENE OVERRIDES //////////////////////////// if (fr.graph.blackboards != null && fr.graph.blackboards.Keys.Count > 0) { EditorHelpers.DrawUILine(); using (new GUILayout.HorizontalScope("Toolbar")) { GUILayout.Label("Blackboard scene overrides", "boldLabel"); } using (new GUILayout.VerticalScope(editorSkin.GetStyle("BoxLine"))) { foreach (var bb in fr.graph.blackboards.Keys) { if (fr.graph.blackboards[bb].blackboard == null) { EditorGUILayout.HelpBox("Blackboard is empty, please assign a blackboard asset to the graph", MessageType.Warning); continue; } using (new GUILayout.HorizontalScope(FlowReactorEditorStyles.overflowButton)) { fr.graph.blackboards[bb].foldout = EditorGUILayout.Foldout(fr.graph.blackboards[bb].foldout, fr.graph.blackboards[bb].blackboard.name); } if (fr.graph.blackboards[bb].foldout) { foreach (var key in fr.graph.blackboards[bb].blackboard.variables.Keys) { FRVariable value = null; // object is in the scene but variable is not set as overridable if (fr.overrideSceneVariables.TryGetValue(key.ToString(), out value) && !IsObjectPrefabInProject()) { using (new GUILayout.HorizontalScope()) { EditorGUI.BeginChangeCheck(); if (fr.graph.blackboards[bb].blackboard.variables[key].sceneReferenceOnly) { GUI.enabled = false; value.overrideVariable = true; } value.overrideVariable = GUILayout.Toggle(value.overrideVariable, "Override", GUILayout.Width(100)); GUI.enabled = true; if (value.overrideVariable == false) { //fr.overrideSceneVariables.Remove(key.ToString()); GUI.enabled = false; GUILayout.Label(fr.graph.blackboards[bb].blackboard.variables[key].name); if (fr.graph.blackboards[bb].blackboard.variables[key].useDatabox) { GUILayout.Label(fr.graph.blackboards[bb].blackboard.variables[key].databoxID + " | " + fr.graph.blackboards[bb].blackboard.variables[key].tableID + " | " + fr.graph.blackboards[bb].blackboard.variables[key].entryID + " | " + fr.graph.blackboards[bb].blackboard.variables[key].tableID); } else { fr.graph.blackboards[bb].blackboard.variables[key].Draw(true, null); } GUI.enabled = true; } else { GUI.enabled = true; //GUILayout.Label(value.name); GUILayout.Label(fr.graph.blackboards[bb].blackboard.variables[key].name); value.Draw(true, null); } GUI.enabled = true; if (EditorGUI.EndChangeCheck() && !Application.isPlaying) { UnityEditor.SceneManagement.EditorSceneManager.MarkSceneDirty(UnityEditor.SceneManagement.EditorSceneManager.GetActiveScene()); } } } // object lives in the scene else { using (new GUILayout.HorizontalScope()) { var v = fr.graph.blackboards[bb].blackboard.variables[key] as FRVariable; if (!IsObjectPrefabInProject()) { if (v.sceneReferenceOnly) { GUI.enabled = false; v.overrideVariable = true; } } else { GUI.enabled = false; } v.overrideVariable = GUILayout.Toggle(v.overrideVariable, "Override", GUILayout.Width(100)); GUI.enabled = true; if (v.overrideVariable) { // create new item and copy it to the override variables var _newOverrideVariable = (FRVariable)Activator.CreateInstance(fr.graph.blackboards[bb].blackboard.variables[key].GetType()); _newOverrideVariable.overrideVariable = true; _newOverrideVariable.name = v.name; fr.overrideSceneVariables.Add(key.ToString(), _newOverrideVariable); fr.overrideSceneVariables[key.ToString()].overrideVariable = true; fr.overrideSceneVariables[key.ToString()].name = v.name; v.overrideVariable = false; // blackboard is always false } GUI.enabled = false; GUILayout.Label(v.name); if (fr.graph.blackboards[bb].blackboard.variables[key].useDatabox) { GUILayout.Label(fr.graph.blackboards[bb].blackboard.variables[key].databoxID + " | " + fr.graph.blackboards[bb].blackboard.variables[key].tableID + " | " + fr.graph.blackboards[bb].blackboard.variables[key].entryID + " | " + fr.graph.blackboards[bb].blackboard.variables[key].tableID); } else { fr.graph.blackboards[bb].blackboard.variables[key].Draw(true, null); } GUI.enabled = true; } } } GUILayout.Space(10); EditorHelpers.DrawUILine(); } // cleanup override variables if they don't exist in the blackboard anymore foreach (var kc in fr.overrideSceneVariables.Keys) { bool _overrideVarExists = false; foreach (var bc in fr.graph.blackboards.Keys) { if (fr.graph.blackboards[bc].blackboard.variables.ContainsKey(Guid.Parse(kc))) { _overrideVarExists = true; } } if (!_overrideVarExists) { Debug.Log("cleanup"); cleanupKeys.Add(kc.ToString()); } } } } } for (int c = 0; c < cleanupKeys.Count; c++) { #if FLOWREACTOR_DEBUG Debug.Log("remove override variable " + cleanupKeys[c]); #endif Debug.Log("remove"); fr.overrideSceneVariables.Remove(cleanupKeys[c]); } // only for debug #if FLOWREACTOR_DEBUG DrawDefaultInspector(); #endif if (EditorGUI.EndChangeCheck()) { EditorUtility.SetDirty(target); } serializedObject.Update(); serializedObject.ApplyModifiedProperties(); }
public void DrawDefaultGUI(GraphEditor _editor, EventBoard _eventBoard) { if (editorSkin == null) { editorSkin = EditorHelpers.LoadSkin(); } if (settings == null) { settings = FREditorSettings.GetOrCreateSettings(); } using (new GUILayout.VerticalScope(editorSkin.GetStyle("Box"))) { GUILayout.Label("Event name:"); using (new GUILayout.HorizontalScope()) { newEventName = GUILayout.TextField(newEventName); if (GUILayout.Button("Add Event")) { if (_eventBoard.events == null) { _eventBoard.events = new FlowReactor.OrderedDictionary.OrderedDictionary <Guid, EventBoard.Event>(); } _eventBoard.AddNewEvent(newEventName); newEventName = ""; } } } if (_eventBoard.events == null) { return; } if (_eventBoard.events.Keys.Count == 0) { return; } var _events = _eventBoard.events.Keys.ToList(); var _statsFoldout = new List <bool>(new bool[_events.Count]); GUILayout.Label("Events:", "boldLabel"); EditorHelpers.DrawUILine(); try{ for (int e = 0; e < _events.Count; e++) { using (new GUILayout.HorizontalScope("toolbar")) { GUILayout.Space(10); _eventBoard.events[_events[e]].foldout = EditorGUILayout.Foldout(_eventBoard.events[_events[e]].foldout, _eventBoard.events[_events[e]].name); if (e > 0) { if (GUILayout.Button("▲", "toolbarButton", GUILayout.Width(20))) { var _e = _eventBoard.events[_events[e]]; _eventBoard.events.RemoveAt(e); _eventBoard.events.Insert(e - 1, _events[e], _e); } } if (e < _events.Count - 1) { if (GUILayout.Button("▼", "toolbarButton", GUILayout.Width(20))) { var _e = _eventBoard.events[_events[e]]; _eventBoard.events.RemoveAt(e); _eventBoard.events.Insert(e + 1, _events[e], _e); } } if (GUILayout.Button("x", "toolbarButton", GUILayout.Width(20))) { _eventBoard.events.Remove(_events[e]); } } if (_eventBoard.events[_events[e]].foldout) { using (new GUILayout.VerticalScope(editorSkin.GetStyle("Box"))) { var _noCallEventNodes = false; var _noEventListenerNodes = false; if (_eventBoard.events[_events[e]].callEventNodes != null) { if (_eventBoard.events[_events[e]].callEventNodes.Count == 0) { _noCallEventNodes = true; } } else { _noCallEventNodes = true; } if (_eventBoard.events[_events[e]].listenerEventNodes != null) { if (_eventBoard.events[_events[e]].listenerEventNodes.Count == 0) { _noEventListenerNodes = true; } } else { _noEventListenerNodes = true; } if (_noCallEventNodes && _noEventListenerNodes) { EditorGUILayout.HelpBox("Event is not being used in any graph", MessageType.Warning); } using (new GUILayout.HorizontalScope()) //editorSkin.GetStyle("Box"))) { //GUILayout.Label("Event:"); _eventBoard.events[_events[e]].name = GUILayout.TextField(_eventBoard.events[_events[e]].name); if (Application.isPlaying) { if (GUILayout.Button("Call Event", "miniButton")) { _eventBoard.events[_events[e]].Raise(null); } } //if (GUILayout.Button("x", GUILayout.Width(20))) //{ // _eventBoard.events.Remove(_events[e]); //} } using (new GUILayout.HorizontalScope()) { GUILayout.Space(20); using (new GUILayout.VerticalScope(editorSkin.GetStyle("BoxLine"))) { if (GUILayout.Button("Add Parameter", "miniButton")) { if (_eventBoard.events[_events[e]].parameters == null) { _eventBoard.events[_events[e]].parameters = new FlowReactor.OrderedDictionary.OrderedDictionary <Guid, FRVariable>(); } var menu = new GenericMenu(); foreach (var key in variableSceneTypes.Keys) { var _data = new GenericMenuData(); _data.type = variableSceneTypes[key]; _data.selected = e; _data.typeName = key; _data.currentEventBoard = _eventBoard; menu.AddItem(new GUIContent(key), false, AddVariableCallback, _data); } menu.ShowAsContext(); } if (_eventBoard.events[_events[e]].parameters != null) { foreach (var p in _eventBoard.events[_events[e]].parameters.Keys) { using (new GUILayout.HorizontalScope()) { GUILayout.Label(_eventBoard.events[_events[e]].parameters[p].typeName, GUILayout.MaxWidth(100)); _eventBoard.events[_events[e]].parameters[p].name = GUILayout.TextField(_eventBoard.events[_events[e]].parameters[p].name); if (GUILayout.Button("x", "miniButton", GUILayout.Width(20))) { _eventBoard.events[_events[e]].parameters.Remove(p); } } } } } } using (new GUILayout.HorizontalScope()) { GUILayout.Space(20); _eventBoard.events[_events[e]].connectedNodeFoldout = EditorGUILayout.Foldout(_eventBoard.events[_events[e]].connectedNodeFoldout, "Connected nodes"); } if (_eventBoard.events[_events[e]].connectedNodeFoldout) { using (new GUILayout.HorizontalScope()) { GUILayout.Space(20); DrawMap(_editor, _eventBoard, _events[e]); } } } } //if (Application.isPlaying && _eventBoard.events[_events[e]].eventListeners != null) //{ // _statsFoldout[e] = EditorGUILayout.Toggle("Stats", _statsFoldout[e]); // if (_statsFoldout[e]) // { // using (new GUILayout.VerticalScope()) // { // GUILayout.Label("Listeners registered to " + _eventBoard.events[_events[e]].name + " :", "boldLabel"); // if (_eventBoard.events[_events[e]].eventListeners != null) // { // GUILayout.Label("Listener count: " + _eventBoard.events[_events[e]].eventListeners.Count.ToString()); // } // for (int l = 0; l < _eventBoard.events[_events[e]].eventListeners.Count; l ++) // { // //GUILayout.Label(l.ToString() + " : " + eventBoard.events[_events[e]].eventListeners[l]); // GUILayout.Label(l.ToString() + " : " + _eventBoard.events[_events[e]].eventListeners[l].graphOwner.name + " - " + _eventBoard.events[_events[e]].eventListeners[l].name); // } // if (_eventBoard.events[_events[e]].eventComponentListeners != null) // { // GUILayout.Label("-----"); // GUILayout.Label("Scene listeners", "boldLabel"); // GUILayout.Label("Listener count: " + _eventBoard.events[_events[e]].eventComponentListeners.Count.ToString()); // for (int l = 0; l < _eventBoard.events[_events[e]].eventComponentListeners.Count; l ++) // { // GUILayout.Label(l.ToString() + " : " + _eventBoard.events[_events[e]].eventComponentListeners[l].name); // } // } // } // } //} } } catch { } EditorUtility.SetDirty(_eventBoard); }
//public void CopyAll<T>(T source, T target) //{ // var type = typeof(T); // foreach (var sourceProperty in type.GetProperties()) // { // var targetProperty = type.GetProperty(sourceProperty.Name); // targetProperty.SetValue(target, sourceProperty.GetValue(source, null), null); // } // foreach (var sourceField in type.GetFields()) // { // var targetField = type.GetField(sourceField.Name); // targetField.SetValue(target, sourceField.GetValue(source)); // } //} // EDITOR Subgraph copy method #if UNITY_EDITOR public Graph CopyEditorSubGraph(Graph _rootGraph, Graph _parentGraph, FlowReactor.Editor.FREditorSettings settings) { Graph _subGraph = Graph.CreateSubGraph("SubGraph", _parentGraph, _rootGraph); _subGraph.isRoot = false; _subGraph.isActive = false; _parentGraph.subGraphs.Add(_subGraph); var _copiedNodes = new List <Node>(); var _selectedNodesList = new List <Node>(nodes); rootGraph.selectedNodes = new Dictionary <int, Node>(); for (int n = 0; n < _selectedNodesList.Count; n++) { SerializationUtility.SerializeValue(_selectedNodesList[n], DataFormat.Binary, out settings.objectReferences); var _original1 = settings.objectReferences[0] as Node; var _newCopy = NodeCreator.CreateNodeFromCopy(_original1.nodeData, _original1, _rootGraph, _subGraph, _original1.nodeData.typeName, 0); _newCopy.outputNodes = new List <Node.NodeOutput>(); _newCopy.inputNodes = new List <Node.InputNode>(); for (int o = 0; o < _original1.outputNodes.Count; o++) { _newCopy.outputNodes.Add(new Node.NodeOutput(_original1.outputNodes[o].outputNode)); _newCopy.outputNodes[_newCopy.outputNodes.Count - 1].guid = _original1.outputNodes[o].guid; } for (int i = 0; i < _original1.inputNodes.Count; i++) { _newCopy.inputNodes.Add(new Node.InputNode(_original1.inputNodes[i].inputNode)); _newCopy.inputNodes[_newCopy.inputNodes.Count - 1].guid = _original1.inputNodes[i].guid; } rootGraph.selectedNodes.Add(_newCopy.GetInstanceID(), _newCopy); _copiedNodes.Add(_newCopy); } // connect in and outputs for (int c = 0; c < _copiedNodes.Count; c++) { _copiedNodes[c].AssignNewOutAndInputsFromList(_copiedNodes); } // Assign new guids for (int n = 0; n < _copiedNodes.Count; n++) { _copiedNodes[n].guid = Guid.NewGuid().ToString(); for (int o = 0; o < _copiedNodes[n].outputNodes.Count; o++) { if (_copiedNodes[n].outputNodes[o].outputNode != null) { for (int i = 0; i < _copiedNodes[n].outputNodes[o].outputNode.inputNodes.Count; i++) { if (_copiedNodes[n].outputNodes[o].outputNode.inputNodes[i].inputNode == _copiedNodes[n]) { _copiedNodes[n].outputNodes[o].outputNode.inputNodes[i].guid = _copiedNodes[n].guid; } } } } for (int o = 0; o < _copiedNodes[n].inputNodes.Count; o++) { for (int i = 0; i < _copiedNodes[n].inputNodes[o].inputNode.outputNodes.Count; i++) { if (_copiedNodes[n].inputNodes[o].inputNode.outputNodes[i].outputNode == _copiedNodes[n]) { _copiedNodes[n].inputNodes[o].inputNode.outputNodes[i].guid = _copiedNodes[n].guid; } } } } for (int h = 0; h < _copiedNodes.Count; h++) { if (_copiedNodes[h].nodeData.nodeType == NodeAttributes.NodeType.SubGraph) { var _subGraphNode = _copiedNodes[h] as SubGraph; var _cs = _subGraphNode.subGraph.CopyEditorSubGraph(_rootGraph, _subGraph, settings); _subGraphNode.subGraph = _cs; _cs.subGraphNode = _subGraphNode; } } return(_subGraph); }
public static void Draw(FREditorSettings _settings) { using (var scrollView = new EditorGUILayout.ScrollViewScope(scrollPosition)) { scrollPosition = scrollView.scrollPosition; if (editorSkin == null) { editorSkin = EditorHelpers.LoadSkin(); } GUI.skin.GetStyle("Label").richText = true; ///////////////// // COLORS //////////////// using (new GUILayout.VerticalScope(editorSkin.GetStyle("BoxLine"))) { GUILayout.Label("<b><size=12>Colors</size></b>"); GUILayout.Space(10); GUILayout.Label("Default colors ID:"); // default colors for (int d = 0; d < _settings.defaultColorsDark.Count; d++) { using (new GUILayout.HorizontalScope(editorSkin.GetStyle("Box"))) { GUILayout.Label(_settings.defaultColorsDark[d].id, GUILayout.Width(100)); GUILayout.Label("Dark skin:"); _settings.defaultColorsDark[d].color = EditorGUILayout.ColorField(_settings.defaultColorsDark[d].color); GUILayout.FlexibleSpace(); GUILayout.Label("Light skin:"); _settings.defaultColorsLight[d].color = EditorGUILayout.ColorField(_settings.defaultColorsLight[d].color); } } GUILayout.Label("Inspector colors"); for (int i = 0; i < _settings.inspectorColors.Count; i++) { using (new GUILayout.HorizontalScope(editorSkin.GetStyle("Box"))) { GUILayout.Label(_settings.inspectorColors[i].id, GUILayout.Width(100)); _settings.inspectorColors[i].color = EditorGUILayout.ColorField(_settings.inspectorColors[i].color); } } EditorHelpers.DrawUILine(); GUILayout.Label("Custom colors ID:"); using (new GUILayout.VerticalScope()) { // custom colors GUILayout.Label("New color ID"); newColorCategory = GUILayout.TextField(newColorCategory); if (colorIDError) { EditorGUILayout.HelpBox("color id already exists", MessageType.Warning); } if (GUILayout.Button("Add new color")) { var _entryExists = _settings.categoryColors.Any(x => x.id == newColorCategory); if (!_entryExists) { colorIDError = false; _settings.categoryColors.Add(new FREditorSettings.EditorColors(newColorCategory, Color.black)); } else { colorIDError = true; } } } for (int c = 0; c < _settings.categoryColors.Count; c++) { using (new GUILayout.HorizontalScope(editorSkin.GetStyle("Box"))) { GUILayout.Label(_settings.categoryColors[c].id); GUILayout.FlexibleSpace(); _settings.categoryColors[c].color = EditorGUILayout.ColorField(_settings.categoryColors[c].color); if (GUILayout.Button("x", GUILayout.Width(20))) { _settings.categoryColors.RemoveAt(c); } } } GUILayout.Space(5); EditorHelpers.DrawUILine(); if (_settings.currentlySelectedGraph != null) { if (GUILayout.Button("Reload nodes with new colors", GUILayout.Height(30))) { for (int n = 0; n < _settings.currentlySelectedGraph.nodes.Count; n++) { _settings.currentlySelectedGraph.nodes[n].ReloadColor(_settings); } for (int s = 0; s < _settings.currentlySelectedGraph.subGraphs.Count; s++) { _settings.currentlySelectedGraph.subGraphs[s].ReloadColors(_settings); } } } if (GUILayout.Button("Reset to default colors", GUILayout.Height(30))) { if (EditorUtility.DisplayDialog("Reset colors?", "Are you sure you wish to reset all colors?", "yes", "no")) { _settings.ResetColors(); } } } using (new GUILayout.VerticalScope(editorSkin.GetStyle("BoxLine"))) { EditorHelpers.DrawUILine(); GUILayout.Space(10); GUILayout.Label("<b><size=12>General</size></b>"); GUILayout.Space(10); using (new GUILayout.HorizontalScope()) { GUILayout.Label("Expand nodes by default:"); _settings.createExpandedNodes = EditorGUILayout.Toggle("", _settings.createExpandedNodes, GUILayout.MaxWidth(200)); } //using (new GUILayout.HorizontalScope()) //{ // GUILayout.Label("Horizontal alignment space:"); // _settings.horizontalAlignmentSpace = EditorGUILayout.IntField(_settings.horizontalAlignmentSpace); //} //using (new GUILayout.HorizontalScope()) //{ // GUILayout.Label("Vertical alignment space:"); // _settings.verticalAlignmentSpace = EditorGUILayout.IntField(_settings.verticalAlignmentSpace); //} } using (new GUILayout.VerticalScope(editorSkin.GetStyle("BoxLine"))) { ///////////////// // SHORTCUTS //////////////// EditorHelpers.DrawUILine(); GUILayout.Space(10); GUILayout.Label("<b><size=12>Editor Shortcuts</size></b>"); EditorGUILayout.HelpBox("It's important to make sure that shortcuts don't conflict with Unity editor shortcuts!", MessageType.Info); GUILayout.Space(10); using (new GUILayout.HorizontalScope()) { GUILayout.Label("Focus: CTRL + "); _settings.keyFocus = (KeyCode)EditorGUILayout.EnumPopup("", _settings.keyFocus, GUILayout.MaxWidth(200)); } using (new GUILayout.HorizontalScope()) { GUILayout.Label("Create comment: CTRL + "); _settings.keyCreateComment = (KeyCode)EditorGUILayout.EnumPopup("", _settings.keyCreateComment, GUILayout.MaxWidth(200)); } using (new GUILayout.HorizontalScope()) { GUILayout.Label("Create Group: CTRL + "); _settings.keyCreateGroup = (KeyCode)EditorGUILayout.EnumPopup("", _settings.keyCreateGroup, GUILayout.MaxWidth(200)); } using (new GUILayout.HorizontalScope()) { GUILayout.Label("Create Sub-Graph: CTRL + ALT + "); _settings.keyCreateSubGraph = (KeyCode)EditorGUILayout.EnumPopup("", _settings.keyCreateSubGraph, GUILayout.MaxWidth(200)); } using (new GUILayout.HorizontalScope()) { GUILayout.Label("Goto parent graph: CTRL + "); _settings.keyGotoParentGraph = (KeyCode)EditorGUILayout.EnumPopup("", _settings.keyGotoParentGraph, GUILayout.MaxWidth(200)); } using (new GUILayout.HorizontalScope()) { GUILayout.Label("Expand nodes: CTRL + "); _settings.keyExpandNodes = (KeyCode)EditorGUILayout.EnumPopup("", _settings.keyExpandNodes, GUILayout.MaxWidth(200)); } using (new GUILayout.HorizontalScope()) { GUILayout.Label("Collapse nodes: CTRL + "); _settings.keyCollapseNodes = (KeyCode)EditorGUILayout.EnumPopup("", _settings.keyCollapseNodes, GUILayout.MaxWidth(200)); } GUILayout.Label("Nodes alignment:", "boldLabel"); using (new GUILayout.HorizontalScope()) { GUILayout.Label("Align to left: CTRL + "); _settings.keyAlignNodesLeft = (KeyCode)EditorGUILayout.EnumPopup("", _settings.keyAlignNodesLeft, GUILayout.MaxWidth(200)); } using (new GUILayout.HorizontalScope()) { GUILayout.Label("Align to right: CTRL + "); _settings.keyAlignNodesRight = (KeyCode)EditorGUILayout.EnumPopup("", _settings.keyAlignNodesRight, GUILayout.MaxWidth(200)); } using (new GUILayout.HorizontalScope()) { GUILayout.Label("Align to top: CTRL + "); _settings.keyAlignNodesTop = (KeyCode)EditorGUILayout.EnumPopup("", _settings.keyAlignNodesTop, GUILayout.MaxWidth(200)); } using (new GUILayout.HorizontalScope()) { GUILayout.Label("Align to bottom: CTRL + "); _settings.keyAlignNodesBottom = (KeyCode)EditorGUILayout.EnumPopup("", _settings.keyAlignNodesBottom, GUILayout.MaxWidth(200)); } using (new GUILayout.HorizontalScope()) { GUILayout.Label("Align automatically: CTRL + "); _settings.keyAlignNodesAutomatically = (KeyCode)EditorGUILayout.EnumPopup("", _settings.keyAlignNodesAutomatically, GUILayout.MaxWidth(200)); } if (GUILayout.Button("Reset to default shortcuts", GUILayout.Height(30))) { if (EditorUtility.DisplayDialog("Reset shortcuts?", "Are you sure you wish to reset all shortcuts?", "yes", "no")) { _settings.ResetShortcuts(); } } if (_settings != null) { EditorUtility.SetDirty(_settings); } } using (new GUILayout.VerticalScope(editorSkin.GetStyle("BoxLine"))) { ///////////////// // RE-Initialize Nodes : Should be used with caution! // Reloads icon, resets node size and sets nodes output back to initial count //////////////// if (_settings.currentlySelectedGraph != null) { EditorHelpers.DrawUILine(); GUILayout.Space(10); GUILayout.Label("<b><size=12>Re-Initialize nodes</size></b>"); EditorGUILayout.HelpBox("Reloads node icons, resets node size and sets the output counts back to their initial count. Warning: This could break some nodes", MessageType.Warning); if (GUILayout.Button("Re-Initialize all nodes", GUILayout.Height(30))) { if (EditorUtility.DisplayDialog("Re-Initialize all nodes", "Are you sure you want to re-initialize all nodes?", "yes", "no")) { for (int n = 0; n < _settings.currentlySelectedGraph.nodes.Count; n++) { _settings.currentlySelectedGraph.nodes[n].ReInitialize(); } for (int s = 0; s < _settings.currentlySelectedGraph.subGraphs.Count; s++) { _settings.currentlySelectedGraph.subGraphs[s].ReInitializeNodes(); } } } } } GUILayout.Space(50); } }
public void OpenExplorer(GraphExplorerWindow _window, Graph _rootGraph, FREditorSettings _settings, GUISkin _editorSkin, GraphEditor _editor) { _editor.graphExplorer = new GraphExplorer(_rootGraph, _settings, _editorSkin, _editor); editor = _editor; _window.Show(); }