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();
}
