/// <summary> /// Adds an arbitrary entry at the given position. /// </summary> /// <returns> /// The entry that was added. /// </returns> /// <param name='position'> /// Position at which the entry should be added. /// </param> /// <typeparam name='T'> /// The type of the entry to be added. /// </typeparam> public T AddEntry <T> (Vector2 position) where T : UTAutomationPlanEntry { CUUndoUtility.RegisterUndo(new UObject[] { data, graphData }, "Add Node"); var entry = UTils.AddAssetOfType <T> (PlanPath, true); entry.automationPlanEntryId = Guid.NewGuid().ToString(); if (data.firstEntry == null) { data.firstEntry = entry; } UTNode node = new UTNode(); node.Data = entry; node.Bounds = new Rect(position.x, position.y, 200, 200); graphData.AddNode(node); // add offset for next node position.x += 50; position.y += 50; EditorUtility.SetDirty(entry); EditorUtility.SetDirty(graphData); SelectNode(node, SelectionMode.Replace); return(entry); }
private void LoadDefaults() { var action = (UTBakeOcclusionCullingAction)target; CUUndoUtility.RegisterUndo(action, "Load default occlusion culling settings"); UTBakeOcclusionCullingAction.LoadDefaults(action); EditorUtility.SetDirty(action); }
private void LoadSettings() { var action = (UTBakeNavMeshAction)target; CUUndoUtility.RegisterUndo(action, "Load default nav mesh settings"); UTBakeNavMeshAction.LoadFromSettings(action); GUIUtility.keyboardControl = 0; // unfocus anything EditorUtility.SetDirty(action); }
/// <summary> /// Relayouts the plan. /// </summary> /// <seealso cref="UTGraphLayouter"/> public void RelayoutPlan() { CUUndoUtility.RegisterUndo(new UObject[] { data, graphData }, "Layout automation plan"); UTGraphLayouter layouter = new UTGraphLayouter(); var node = graphData.GetNodeFor(data.firstEntry); layouter.Relayout(graphData, node); EditorUtility.SetDirty(data); EditorUtility.SetDirty(graphData); }
/// <summary> /// Loads the current settings into the currently selected action if this action implements <see cref="UTICanLoadSettingsFromEditor"/> /// </summary> public virtual void LoadCurrentSettings() { if (target is UTICanLoadSettingsFromEditor) { var action = (UTICanLoadSettingsFromEditor)target; CUUndoUtility.RegisterUndo(target, action.LoadSettingsUndoText); action.LoadSettings(); GUIUtility.keyboardControl = 0; // make sure every textfield is updated. EditorUtility.SetDirty(target); } }
/// <summary> /// Deletes the connection between a node's connector and the target node. /// </summary> /// <param name='connector'> /// Connector for which the connection should be deleted. /// </param> public void DeleteConnection(UTNode.Connector connector) { var sourceEntry = connector.owner.Data; var sourceNode = connector.owner; CUUndoUtility.RegisterUndo(new UObject[] { sourceEntry, graphData }, "Remove connector"); var reference = graphData.GetReference(connector.owner.Data, connector.property); SetProperty(sourceEntry, connector.property, null); sourceNode.Recalc(); graphData.DeleteReference(reference); EditorUtility.SetDirty(sourceEntry); EditorUtility.SetDirty(graphData); }
/// <summary> /// Ensures that the given configuration is activated. If it is already the active configuration this method /// will do nothing. Otherwise it will activate the given configuration and deactivate any other active /// configuration. /// </summary> /// <param name="configurationToBeActivated"> /// A <see cref="SMSceneConfigurationBase"/> that is to be activated. /// </param> public static void EnsureActiveConfiguration(SMSceneConfigurationBase configurationToBeActivated, bool registerUndo) { List <SMSceneConfigurationBase> allConfigurations = FindConfigurations(); if (registerUndo) { CUUndoUtility.RegisterUndo(allConfigurations.ToArray(), "Activate scene configuration"); } foreach (SMSceneConfigurationBase configuration in allConfigurations) { configuration.activeConfiguration = configuration == configurationToBeActivated; EditorUtility.SetDirty(configuration); } }
/// <summary> /// Deletes a set of nodes. Also removes the related automation plan entries from the automation plan. /// </summary> /// <param name='nodes'> /// Nodes to be deleted. /// </param> public void DeleteNodes(IList <UTNode> nodes) { List <UTNode> copy = new List <UTNode> (nodes); List <UObject> toUndo = new List <UObject> (); toUndo.Add(data); toUndo.Add(graphData); foreach (var node in copy) { var targetRefs = graphData.GetTargetReferences(node.Data); foreach (var targetRef in targetRefs) { if (!toUndo.Contains(targetRef.Source)) { toUndo.Add(targetRef.Source); } } } CUUndoUtility.RegisterUndo(toUndo.ToArray(), "Delete nodes"); foreach (var node in copy) { var targetRefs = graphData.GetTargetReferences(node.Data); foreach (var reference in targetRefs) { // kill reference in node SetProperty(reference.Source, reference.SourceProperty, null); var modifiedNode = graphData.GetNodeFor(reference.Source); modifiedNode.Recalc(); } graphData.DeleteNode(node); if (data.firstEntry == node.Data) { data.firstEntry = null; EditorUtility.SetDirty(data); } selectedNodes.Remove(node); // UObject.DestroyImmediate(node.Data, true); } EditorUtility.SetDirty(graphData); }
/// <summary> /// Fixes configuration issues such as multiple active configurations or removed scenes /// </summary> protected void FixConfiguration() { List <UnityEngine.Object> objects = new List <UnityEngine.Object>(SMSceneConfigurationUtil.FindConfigurations().ToArray()); CUUndoUtility.RegisterUndo(objects.ToArray(), "Fixing configuration"); UpdateGuid(); FixInvalidScenes(); if (fixActiveState) { SMSceneConfigurationUtil.EnsureActiveConfiguration(Target, false); } invalidScreens = null; invalidLevels = null; fixActiveState = false; EditorUtility.SetDirty(Target); }
/// <summary> /// Does the actual rendering. Call from the OnInspectorGUI event in your Unity editor. /// </summary> public void OnInspectorGUI() { EditorGUILayout.BeginVertical(); EditorGUI.BeginChangeCheck(); #if UNITY_3_5 || UNITY_4_0 || UNITY_4_0_1 || UNITY_4_1 || UNITY_4_2 Undo.SetSnapshotTarget(target, "inspector change"); Undo.CreateSnapshot(); #else CUUndoUtility.RegisterUndo(target, "inspector change"); #endif DrawAll(); if (EditorGUI.EndChangeCheck()) { #if UNITY_3_5 || UNITY_4_0 || UNITY_4_0_1 || UNITY_4_1 || UNITY_4_2 Undo.RegisterSnapshot(); #endif // no replacement for 4.3+ EditorUtility.SetDirty(target); } EditorGUILayout.EndVertical(); }
/// <summary> /// Adds a connection between a node's connector and another node. /// </summary> /// <param name='sourceConnector'> /// Source connector. /// </param> /// <param name='targetNode'> /// Target node. /// </param> public void AddConnection(UTNode.Connector sourceConnector, UTNode targetNode) { var sourceEntry = sourceConnector.owner.Data; var property = sourceConnector.property; var targetEntry = targetNode.Data; var sourceNode = sourceConnector.owner; CUUndoUtility.RegisterUndo(new UObject[] { sourceEntry, graphData }, "Add connector"); var reference = graphData.GetReference(sourceEntry, property); if (reference == null) { reference = new UTReference(); reference.Source = sourceEntry; reference.SourceProperty = property; graphData.AddReference(reference); } reference.Target = targetEntry; SetProperty(sourceEntry, property, targetEntry); sourceNode.Recalc(); EditorUtility.SetDirty(sourceEntry); EditorUtility.SetDirty(graphData); }
/// <summary> /// Called before anything is changed on the scene configuration. This will register an undo state /// for the scene configuration. /// </summary> /// <param name="operation">the performed operation. this is placed in the undo menu.</param> protected void BeforeChange(string operation) { CUUndoUtility.RegisterUndo(Target, operation); }
/// <summary> /// Called by the node editor before moving nodes. Creates an undo stack frame, so the movement can be undone later. /// </summary> public void StartMovingNodes() { CUUndoUtility.RegisterUndo(new UObject[] { data, graphData }, "Move nodes"); EditorUtility.SetDirty(data); EditorUtility.SetDirty(graphData); }
private PropertyEditorState DrawPropertyEditor(IEnumerable <UTConfigurableProperty> properties, PropertyEditorState state, DoAdd doAdd, PropertyExists propertyExists, DoDelete doDelete, UObject undoTarget) { EditorGUILayout.BeginVertical(); EditorGUILayout.BeginHorizontal(); state.newPropertyName = EditorGUILayout.TextField("Name", state.newPropertyName); GUI.enabled = !string.IsNullOrEmpty(state.newPropertyName) && UTContext.IsValidPropertyName(state.newPropertyName) && !propertyExists(state.newPropertyName); if (GUILayout.Button("Add", UTEditorResources.ExpressionButtonStyle)) { if (undoTarget != null) { CUUndoUtility.RegisterUndo(undoTarget, "Add Property"); } doAdd(state.newPropertyName); state.newPropertyName = ""; } GUI.enabled = true; EditorGUILayout.EndHorizontal(); EditorGUILayout.Space(); scrollPosition = EditorGUILayout.BeginScrollView(scrollPosition); var index = 0; foreach (var property in properties) { EditorGUILayout.BeginVertical(); EditorGUILayout.BeginHorizontal(); if (!property.UseExpression) { if (property.IsPrivate) { property.Value = EditorGUILayout.PasswordField(property.Name, property.Value); } else { property.Value = EditorGUILayout.TextField(property.Name, property.Value); } if (property.SupportsPrivate) { if (GUILayout.Button(property.IsPrivate ? UTEditorResources.PrivateIcon : UTEditorResources.PublicIcon, UTEditorResources.DeleteButtonStyle)) { property.IsPrivate = !property.IsPrivate; GUIUtility.keyboardControl = 0; // make textfield update. } } } else { property.Expression = EditorGUILayout.TextField(property.Name, property.Expression); } if (GUILayout.Button(UTEditorResources.DeleteIcon, UTEditorResources.DeleteButtonStyle)) { if (undoTarget != null) { CUUndoUtility.RegisterUndo(undoTarget, "Remove property"); } doDelete(property); GUIUtility.ExitGUI(); } var oldExpression = property.UseExpression; property.UseExpression = GUILayout.Toggle(oldExpression, UTEditorResources.ExpressionButton, UTEditorResources.ExpressionButtonStyle); if (oldExpression != property.UseExpression) { GUIUtility.keyboardControl = 0; // make textfield update. } EditorGUILayout.EndHorizontal(); if (!property.UseExpression && property.Value.Contains("$")) { EditorGUILayout.HelpBox(UTEditorResources.VariableWarningText, MessageType.Warning); } EditorGUILayout.EndVertical(); index++; } EditorGUILayout.EndScrollView(); EditorGUILayout.EndVertical(); return(state); }