private void AddNewCurve() { Undo.RecordObject(spline, "Add Curve"); spline.AddCurve(); EditorUtility.SetDirty(spline); Undo.FlushUndoRecordObjects(); }
public IEnumerator CreateAndDestroyOperationGameObject_Undo_OperationExists() { var scene = TestUtility.defaultScene; var operation = TestUtility.CreateUndoableGameObjectWithOperation(); var operationGameObject = operation.gameObject; Assert.AreEqual(0, CSGManager.TreeBranchCount, "Expected 0 TreeBranches to Exist"); Assert.AreEqual(0, CSGManager.TreeNodeCount, "Expected 0 TreeNodes to Exist"); Undo.FlushUndoRecordObjects(); Undo.IncrementCurrentGroup(); yield return(null); Assert.AreEqual(1, CSGManager.TreeBranchCount, "Expected 1 TreeBranch to Exist"); Assert.AreEqual(2, CSGManager.TreeNodeCount, "Expected 2 TreeNodes to Exist"); Undo.DestroyObjectImmediate(operationGameObject); yield return(null); Assert.False(operationGameObject); Assert.False(operation); Assert.AreEqual(0, CSGManager.TreeBranchCount, "Expected 0 TreeBranches to Exist"); Assert.AreEqual(0, CSGManager.TreeNodeCount, "Expected 0 TreeNodes to Exist"); Assert.AreEqual(0, ChiselNodeHierarchyManager.RootCount(scene)); Undo.PerformUndo(); operation = Object.FindObjectsOfType <ChiselOperation>()[0]; operationGameObject = operation.gameObject; yield return(null); Assert.True(operationGameObject); Assert.True(operation); Assert.AreEqual(1, CSGManager.TreeBranchCount, "Expected 1 TreeBranch to Exist"); Assert.AreEqual(2, CSGManager.TreeNodeCount, "Expected 2 TreeNodes to Exist"); Assert.AreEqual(1, ChiselNodeHierarchyManager.RootCount(scene)); }
private void UpdateEditor() { if (lastTimeSinceStartup == 0f) { lastTimeSinceStartup = EditorApplication.timeSinceStartup; } editorDeltaTime = EditorApplication.timeSinceStartup - lastTimeSinceStartup; lastTimeSinceStartup = EditorApplication.timeSinceStartup; var cached = GetParameter <CachedGameObjects>().gameObjects; if (cached.Count > 0) { Undo.RegisterCompleteObjectUndo(cached.ToArray(), "Magnet Objs"); Undo.FlushUndoRecordObjects(); for (int i = 0; i < cached.Count; i++) { var heading = raycastHit.point - cached[i].transform.position; var distance = heading.magnitude; if (distance <= GetParameter <Radius>().value) { var direction = heading / distance; int sign = GetParameter <Outer>().value ? -1 : 1; cached[i].transform.position += direction * sign * (float)editorDeltaTime * GetParameter <FloatParameter>().value; } else { GetParameter <CachedGameObjects>().gameObjects.Remove(cached[i]); return; } } } }
public IEnumerator CreateModel_UndoCreateGameObject_DoesNotDirtyAnyScene() { var currentScene = SceneManager.GetActiveScene(); var newScene = TestUtility.CreateAdditionalSceneAndActivate(); Assert.False(currentScene.isDirty); Assert.False(newScene.isDirty); Undo.FlushUndoRecordObjects(); Undo.IncrementCurrentGroup(); yield return(null); var model = TestUtility.CreateUndoableGameObjectWithModel(); var modelGameObject = model.gameObject; Assert.AreEqual(modelGameObject.scene, newScene); Assert.True(newScene.isDirty); Assert.False(currentScene.isDirty); Undo.PerformUndo(); yield return(null); Assert.False(modelGameObject); Assert.False(model); Assert.False(newScene.isDirty); Assert.False(currentScene.isDirty); }
private void OnSceneGUI() { var dungeon = (RuntimeDungeon)target; if (!dungeon.Generator.RestrictDungeonToBounds) { return; } placementBoundsHandle.center = dungeon.Generator.TilePlacementBounds.center; placementBoundsHandle.size = dungeon.Generator.TilePlacementBounds.size; EditorGUI.BeginChangeCheck(); using (new Handles.DrawingScope(dungeon.transform.localToWorldMatrix)) { placementBoundsHandle.DrawHandle(); } if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(dungeon, "Inspector"); dungeon.Generator.TilePlacementBounds = new Bounds(placementBoundsHandle.center, placementBoundsHandle.size); Undo.FlushUndoRecordObjects(); } }
private static void SetLevelLoaderSceneName(string scenePath, string extraScenePath) { var sceneName = Path.GetFileNameWithoutExtension(extraScenePath); var modified = ModifyRootGameObject <AdditiveLevelLoader>(scenePath, (levelLoader) => { if (!string.Equals(levelLoader.sceneName, sceneName)) { levelLoader.sceneName = sceneName; Debug.Log("BUILD:: Set scene name on additive level loader (" + levelLoader.ToString() + ") == " + levelLoader.sceneName); } }); if (!modified) { var go = new GameObject("AdditiveLevelLoader"); Undo.RegisterCreatedObjectUndo(go, "Created additive level loader"); var levelLoader = Undo.AddComponent <AdditiveLevelLoader>(go); Undo.RecordObject(levelLoader, "Set additive level loader scene name"); levelLoader.sceneName = sceneName; Undo.FlushUndoRecordObjects(); EditorSceneManager.SaveOpenScenes(); Debug.Log("BUILD:: Create an additive level loader & set scene name on it (" + levelLoader.ToString() + ") == " + levelLoader.sceneName); } }
void NormalizeMesh() { string undoName = $"Normalize Mesh \"{m_target.gameObject.name}\""; Undo.RecordObject(m_target.transform, undoName); Undo.RecordObject(m_target.Filter, undoName); var verts = m_target.Mesh.vertices; for (int i = 0; i < verts.Length; i++) { verts[i] = m_target.transform.TransformPoint(verts[i]); } Mesh mesh = Instantiate(m_target.Mesh); Undo.RegisterCreatedObjectUndo(mesh, undoName); m_target.Filter.sharedMesh = mesh; m_target.transform.localScale = Vector3.one; for (int i = 0; i < verts.Length; i++) { verts[i] = m_target.transform.InverseTransformPoint(verts[i]); } mesh.vertices = verts; mesh.triangles = mesh.triangles.Reverse().ToArray(); mesh.RecalculateNormals(); Undo.FlushUndoRecordObjects(); }
public void SortByY(string layerName) { SpriteRenderer[] sprites = FindObjectsOfType <SpriteRenderer>(); foreach (var sprite in sprites) { bool isInLayer = sprite.sortingLayerName == layerName; if (isInLayer) { Undo.RegisterCompleteObjectUndo(sprite.transform, "SortByY"); sprite.sortingOrder = SpriteSortingOrderProvider.GetSortingOrder(sprite.gameObject); } } SpriteGroup[] groups = FindObjectsOfType <SpriteGroup>(); foreach (var group in groups) { bool isInLayer = group.sortingLayerName == layerName; if (isInLayer) { Undo.RegisterCompleteObjectUndo(group, "SortByY"); group.sortingOrder = -(int)(group.transform.position.y * 100); } } Undo.FlushUndoRecordObjects(); }
public IEnumerator CreateAndDestroyCompositeComponent_Undo_CompositeExists() { var scene = TestUtility.defaultScene; var composite = TestUtility.CreateGameObjectWithUndoableCompositeComponent(); var compositeGameObject = composite.gameObject; Assert.AreEqual(0, CSGManager.TreeBranchCount, "Expected 0 TreeBranches to Exist"); Assert.AreEqual(0, CSGManager.TreeNodeCount, "Expected 0 TreeNodes to Exist"); Undo.FlushUndoRecordObjects(); Undo.IncrementCurrentGroup(); yield return(null); Assert.AreEqual(1, CSGManager.TreeBranchCount, "Expected 1 TreeBranch to Exist"); Assert.AreEqual(2, CSGManager.TreeNodeCount, "Expected 2 TreeNodes to Exist"); Undo.DestroyObjectImmediate(composite); yield return(null); Assert.True(compositeGameObject); Assert.False(composite); Assert.AreEqual(0, CSGManager.TreeBranchCount, "Expected 0 TreeBranches to Exist"); Assert.AreEqual(0, CSGManager.TreeNodeCount, "Expected 0 TreeNodes to Exist"); Assert.AreEqual(0, ChiselNodeHierarchyManager.RootCount(scene)); Undo.PerformUndo(); composite = compositeGameObject.GetComponent <ChiselComposite>(); yield return(null); Assert.True(compositeGameObject); Assert.True(composite); Assert.AreEqual(1, CSGManager.TreeBranchCount, "Expected 1 TreeBranch to Exist"); Assert.AreEqual(2, CSGManager.TreeNodeCount, "Expected 2 TreeNodes to Exist"); Assert.AreEqual(1, ChiselNodeHierarchyManager.RootCount(scene)); }
internal override void OnHeaderControlsGUI() { var preset = target as Preset; if (preset != null) { using (new EditorGUI.DisabledScope(targets.Length != 1 || !preset.GetPresetType().IsValidDefault())) { var defaultList = Preset.GetDefaultPresetsForType(preset.GetPresetType()).Where(d => d.preset == preset); if (defaultList.Any()) { if (GUILayout.Button(GUIContent.Temp(string.Format(Style.removeFromDefault.text, preset.GetTargetTypeName()), Style.removeFromDefault.tooltip), EditorStyles.miniButton, GUILayout.ExpandWidth(false))) { Undo.RecordObject(Resources.FindObjectsOfTypeAll <PresetManager>().First(), "Preset Manager"); Preset.RemoveFromDefault(preset); Undo.FlushUndoRecordObjects(); } } else { if (GUILayout.Button(GUIContent.Temp(string.Format(Style.addToDefault.text, preset.GetTargetTypeName()), Style.addToDefault.tooltip), EditorStyles.miniButton, GUILayout.ExpandWidth(false))) { Undo.RecordObject(Resources.FindObjectsOfTypeAll <PresetManager>().First(), "Preset Manager"); var list = Preset.GetDefaultPresetsForType(preset.GetPresetType()).ToList(); list.Insert(0, new DefaultPreset(string.Empty, preset)); Preset.SetDefaultPresetsForType(preset.GetPresetType(), list.ToArray()); Undo.FlushUndoRecordObjects(); } } } } }
protected override void CloseScope() { if (_serializedObject != null) { _serializedObject.ApplyModifiedProperties(); } else { Undo.FlushUndoRecordObjects(); var changed = EditorGUI.EndChangeCheck(); if (_object && (changed || _forceDirty)) { // SetDirty is for assets (including prefabs), MarkSceneDirty is for GameObjects if (!Application.isPlaying) { EditorUtility.SetDirty(_object); // Set dirty doesn't mark scene as dirty if (_object is GameObject obj) { EditorSceneManager.MarkSceneDirty(obj.scene); } else if (_object is MonoBehaviour behaviour) { EditorSceneManager.MarkSceneDirty(behaviour.gameObject.scene); } } } } Undo.CollapseUndoOperations(_group); }
private void OnMouseDown() { if (m_Dragging || m_Moving) { return; } if (Event.current.button == 0) { foreach (var state in m_SelectedProfile.States) { var position = m_StatesViewRect.position + m_StatesViewOffset + state.StateEditorPosition; var rect = new Rect(position.x, position.y, STATE_WIDTH, STATE_HEIGHT); if (rect.Contains(Event.current.mousePosition)) { m_Moving = true; m_MovingState = state; m_SelectedState = state; return; } } } else if (Event.current.button == 1) { Undo.RecordObject(m_SelectedProfile, "Added New State"); m_SelectedProfile.AddState(); Undo.FlushUndoRecordObjects(); Repaint(); } else if (Event.current.button == 2) { m_Dragging = true; } }
private void UpdateInputs() { var targetProfile = m_SelectedProfile == null ? m_SelectedComponent.Profile : m_SelectedProfile; if (m_Moving) { if (!m_StatesViewRect.Contains(Event.current.mousePosition)) { m_Moving = false; m_MovingState = null; } else { Undo.RecordObject(targetProfile, "State Position Moved"); m_MovingState.StateEditorPosition += Event.current.delta / 2f; Undo.FlushUndoRecordObjects(); Repaint(); } } else if (m_Dragging) { m_StatesViewOffset += Event.current.delta / 2f; Repaint(); } }
private void DrawStateInspector(Rect rect) { EditorGUI.DrawRect(rect, new Color(56f / 255f, 56f / 255f, 56f / 255f)); var offset = new Rect(rect); offset.height = EditorGUIUtility.singleLineHeight; var targetProfile = m_SelectedProfile == null ? m_SelectedComponent.Profile : m_SelectedProfile; if (m_SelectedState != null) { var newString = EditorGUI.TextField(offset, "Name", m_SelectedState.Name); if (newString != m_SelectedState.Name) { Undo.RecordObject(targetProfile, "State Name Changed"); m_SelectedState.Name = newString; Undo.FlushUndoRecordObjects(); Repaint(); } offset.y += EditorGUIUtility.singleLineHeight; var so = new SerializedObject(targetProfile); var spIndex = Array.IndexOf(targetProfile.States, m_SelectedState); var sp = so.FindProperty("m_States").GetArrayElementAtIndex(spIndex); for (var i = 0; i < m_SelectedState.Behaviours.Length; i++) { var serializedBehaviour = sp.FindPropertyRelative("m_Behaviours"); DrawStateBehaviour(so, serializedBehaviour.GetArrayElementAtIndex(i), rect, ref offset); } } }
void PushUndo(Vector3[] normals, History.Record[] records) { Undo.IncrementCurrentGroup(); Undo.RecordObject(this, "NormalEditor [" + m_history.index + "]"); m_historyIndex = ++m_history.index; if (normals == null) { m_history.normals = null; } else { if (m_history.normals != null && m_history.normals.Length == normals.Length) { Array.Copy(normals, m_history.normals, normals.Length); } else { m_history.normals = (Vector3[])normals.Clone(); } if (m_settings.tangentsMode == TangentsUpdateMode.Auto) { RecalculateTangents(); } } m_history.records = records != null ? (History.Record[])records.Clone() : null; Undo.FlushUndoRecordObjects(); }
private ReorderableList GetOrCreateList(SerializedProperty property, GUIContent label) { ReorderableList list = null; if (lists.TryGetValue(property.propertyPath, out list)) { return(list); } else { var weightsProperty = property.FindPropertyRelative("Weights"); var targetObject = property.serializedObject.targetObject; var chanceTable = (GameObjectChanceTable)fieldInfo.GetValue(targetObject); list = new ReorderableList(property.serializedObject, weightsProperty, true, true, true, true) { drawElementCallback = (rect, index, isActive, isFocused) => EditorGUI.PropertyField(rect, weightsProperty.GetArrayElementAtIndex(index), GUIContent.none), drawHeaderCallback = (rect) => EditorGUI.LabelField(rect, label.text + " (" + weightsProperty.arraySize + ")"), elementHeightCallback = (index) => EditorGUI.GetPropertyHeight(weightsProperty.GetArrayElementAtIndex(index)), onAddCallback = (l) => { Undo.RecordObject(targetObject, "Add GameObject Chance"); chanceTable.Weights.Add(new GameObjectChance()); Undo.FlushUndoRecordObjects(); }, }; lists[property.propertyPath] = list; return(list); } }
/// <summary> /// Draw the inspector GUI. /// </summary> public override void OnInspectorGUI() { sceneViewInspectorId = this.GetInstanceID(); // Unity says we don't need to do this, but if we don't do this then the automatic serialised object updates get the same name as the last object recorded Undo.FlushUndoRecordObjects(); Undo.RecordObject(target, "Sequenced Enemy Update"); EditorGUILayout.HelpBox("The sequence driven enemy allows you to specify a sequence of actions (with optional loops) and is well suited to bosses.", MessageType.Info, true); GUILayout.Space(10); foldOut = EditorGUILayout.Foldout(foldOut, "Basic Settings"); if (foldOut) { DrawDefaultInspector(); DrawFallInspector((Enemy)target); DrawSenseInspector((SequenceDrivenEnemy)target); } sequenceFoldOut = EditorGUILayout.Foldout(sequenceFoldOut, "Sequence"); if (!Application.isPlaying) { if (sequenceFoldOut) { DrawSequenceInspector((SequenceDrivenEnemy)target); } } else { DrawPlayModeSequenceInspector((SequenceDrivenEnemy)target); } ShowWarnings(); DrawEnemyDebugger((Enemy)target); }
/// <summary> /// Draw inspector GUI. /// </summary> public override void OnInspectorGUI() { Undo.FlushUndoRecordObjects(); Undo.RecordObject(target, "Enemy Waypoint Update"); sceneViewInspectorId = this.GetInstanceID(); // Ensure 1 waypoint if (((EnemyMovement_WaypointMover)target).wayPoints == null || ((EnemyMovement_WaypointMover)target).wayPoints.Count < 2) { List <Vector2> waypoints = new List <Vector2>(); waypoints.Add(((EnemyMovement_WaypointMover)target).transform.position); waypoints.Add(((EnemyMovement_WaypointMover)target).transform.position + Vector3.one); ((EnemyMovement_WaypointMover)target).wayPoints = waypoints; } DrawDefaultInspector(); GUI.color = editWaypoints ? Color.red: Color.white; if (GUILayout.Button("Edit Waypoints in Scene")) { editWaypoints = !editWaypoints; SceneView.RepaintAll(); } GUI.color = Color.white; }
public IEnumerator CreateAndDestroyBrushGameObject_Undo_BrushExists() { var scene = TestUtility.defaultScene; var brush = TestUtility.CreateUndoableGameObjectWithBrush(); var brushGameObject = brush.gameObject; Assert.AreEqual(0, CSGManager.TreeBrushCount, "Expected 0 TreeBrushes to Exist"); Assert.AreEqual(0, CSGManager.TreeNodeCount, "Expected 0 TreeNodes to Exist"); Undo.FlushUndoRecordObjects(); Undo.IncrementCurrentGroup(); yield return(null); Assert.AreEqual(1, CSGManager.TreeBrushCount, "Expected 1 TreeBrush to Exist"); Assert.AreEqual(2, CSGManager.TreeNodeCount, "Expected 2 TreeNodes to Exist"); Undo.DestroyObjectImmediate(brushGameObject); yield return(null); Assert.False(brushGameObject); Assert.False(brush); Assert.AreEqual(0, CSGManager.TreeBrushCount, "Expected 0 TreeBrushes to Exist"); Assert.AreEqual(0, CSGManager.TreeNodeCount, "Expected 0 TreeNodes to Exist"); Assert.AreEqual(0, CSGNodeHierarchyManager.RootCount(scene)); Undo.PerformUndo(); brush = Object.FindObjectsOfType <ChiselBrush>()[0]; brushGameObject = brush.gameObject; yield return(null); Assert.True(brushGameObject); Assert.True(brush); Assert.AreEqual(1, CSGManager.TreeBrushCount, "Expected 1 TreeBrush to Exist"); Assert.AreEqual(2, CSGManager.TreeNodeCount, "Expected 2 TreeNodes to Exist"); Assert.AreEqual(1, CSGNodeHierarchyManager.RootCount(scene)); }
private static void Group() { //没选中物体能干啥 if (Selection.objects.Length == 0) { return; } //new一个gameObject去装选中的物体 GameObject[] gameObjects = Selection.gameObjects; Transform parent = gameObjects[0].transform.parent; int nSiblingIndex = gameObjects[0].transform.GetSiblingIndex(); GameObject go = new GameObject("Group"); Undo.RegisterCreatedObjectUndo(go, "CreateEmpty"); Undo.FlushUndoRecordObjects(); for (int i = 0; i < gameObjects.Length; i++) { GameObject gameObject = gameObjects[i]; Undo.SetTransformParent(gameObject.transform, go.transform, "Group"); } go.transform.Parent(parent).SiblingIndex(nSiblingIndex); EditorGUIUtility.PingObject(gameObjects[0]); }
public IEnumerator CreateAndDestroyModelGameObject_Undo_ModelExist() { var scene = TestUtility.defaultScene; var model = TestUtility.CreateUndoableGameObjectWithModel(); var modelGameObject = model.gameObject; Assert.AreEqual(0, CSGManager.TreeCount, "Expected 0 Trees to Exist"); Assert.AreEqual(0, CSGManager.TreeNodeCount, "Expected 0 TreeNodes to Exist"); Undo.FlushUndoRecordObjects(); Undo.IncrementCurrentGroup(); yield return(null); Assert.AreEqual(1, CSGManager.TreeCount, "Expected 1 Tree to Exist"); Assert.AreEqual(1, CSGManager.TreeNodeCount, "Expected 1 TreeNode to Exist"); Undo.DestroyObjectImmediate(modelGameObject); yield return(null); Assert.False(modelGameObject); Assert.False(model); Assert.AreEqual(0, CSGManager.TreeCount, "Expected 0 Trees to Exist"); Assert.AreEqual(0, CSGManager.TreeNodeCount, "Expected 0 TreeNodes to Exist"); Undo.PerformUndo(); yield return(null); model = modelGameObject.GetComponent <ChiselModel>(); yield return(null); Assert.True(modelGameObject); Assert.True(model); Assert.AreEqual(1, CSGManager.TreeCount, "Expected 1 Tree to Exist"); Assert.AreEqual(1, CSGManager.TreeNodeCount, "Expected 1 TreeNode to Exist"); Assert.AreEqual(1, CSGNodeHierarchyManager.RootCount(scene)); }
private static void DrawActivityToggle(Rect rect, GameObject go) { // Get's style of toggle bool active = go.activeInHierarchy; GUIStyle toggleStyle = active ? ToggleStyleName : MixedToggleStyleName; // Sets rect for toggle Rect toggleRect = new Rect(rect); toggleRect.width = toggleRect.height; toggleRect.x -= 28; // Creates toggle bool state = GUI.Toggle(toggleRect, go.activeSelf, GUIContent.none, toggleStyle); // Sets game's active state to result of toggle if (state == go.activeSelf) { return; } Undo.RecordObject(go, $"{(state ? "Enabled" : "Disabled")}"); go.SetActive(state); Undo.FlushUndoRecordObjects(); }
public override void UnlockMesh() { m_lockMeshIntermediateState = LockMeshIntermediateStateEnum.PreUnlock; #if UNITY_EDITOR Undo.RecordObject(this, "Unlock Mesh (" + name + ")"); #endif base.UnlockMesh(); #if UNITY_EDITOR Undo.FlushUndoRecordObjects(); #endif RemoveComponentHelper <MeshCollider>(gameObject); RemoveComponentHelper <Rigidbody>(gameObject); RemoveComponentHelper <MeshFilter>(gameObject); RemoveComponentHelper <MeshRenderer>(gameObject); RemoveComponentHelper <SkinnedMeshRenderer>(gameObject); RemoveComponentHelper <MudLockedMeshRenderer>(gameObject); RemoveComponentHelper <MudStandardMeshRenderer>(gameObject); m_lockMeshIntermediateState = LockMeshIntermediateStateEnum.Idle; MeshGenerationLockOnStartByEditor = false; m_addedComponents = null; }
/// <summary> /// Records the given operation /// </summary> private static void RecordOperation (UndoProRecord operation) { // First, make sure the internal records representation is updated UpdateUndoRecords (); // Make sure this record isn't included in the previous group Undo.IncrementCurrentGroup (); // Create a dummy record with the given label if (dummyObject == null) dummyObject = new Texture2D (8, 8); Undo.RegisterCompleteObjectUndo (dummyObject, operation.label); // Make sure future undo records are not included into this group Undo.FlushUndoRecordObjects (); Undo.IncrementCurrentGroup (); // Now get the new Undo state records.undoState = FetchUndoState (); // Record operation internally records.UndoRecordsAdded (1); records.undoProRecords.Add (operation); if (OnAddUndoRecord != null) OnAddUndoRecord.Invoke (new string[] { operation.label }, true); }
public IEnumerator CreateOperation_UndoCreateComponent_DoesNotDirtyAnyScene() { var currentScene = SceneManager.GetActiveScene(); var newScene = TestUtility.CreateAdditionalSceneAndActivate(); Assert.False(currentScene.isDirty); Assert.False(newScene.isDirty); Undo.FlushUndoRecordObjects(); Undo.IncrementCurrentGroup(); yield return(null); var operation = TestUtility.CreateGameObjectWithUndoableBrushComponent(); var operationGameObject = operation.gameObject; Assert.AreEqual(newScene, operationGameObject.scene); Assert.True(newScene.isDirty); Assert.False(currentScene.isDirty); Undo.PerformUndo(); yield return(null); Assert.True(operationGameObject); Assert.False(operation); Assert.False(newScene.isDirty); Assert.False(currentScene.isDirty); }
void PushUndo() { if (m_settings.normalMode == RecalculateMode.Auto) { RecalculateNormalsInternal(); } // recalculating tangents require normals. so recalculate only when normals are updated if (m_settings.tangentsMode == RecalculateMode.Auto && (m_settings.normalMode == RecalculateMode.Auto || m_settings.normalMode == RecalculateMode.Realtime)) { RecalculateTangentsInternal(); } Undo.IncrementCurrentGroup(); Undo.RecordObject(this, "VertexTweaker [" + m_history.index + "]"); m_historyIndex = ++m_history.index; if (m_history.points == null || m_history.points.Length != m_points.Count) { m_history.points = m_pointsPredeformed.Clone(); m_history.normals = m_normalsPredeformed.Clone(); m_history.tangents = m_tangentsPredeformed.Clone(); } else { Array.Copy(m_pointsPredeformed, m_history.points, m_points.Count); Array.Copy(m_normalsPredeformed, m_history.normals, m_normals.Count); Array.Copy(m_tangentsPredeformed, m_history.tangents, m_tangents.Count); } m_history.mesh = m_meshTarget; Undo.FlushUndoRecordObjects(); //Debug.Log("PushUndo " + m_historyIndex); }
private static void Group() { GameObject[] gameObjects = Selection.gameObjects; if (gameObjects.Length == 0) { return; } Transform parent = gameObjects[0].transform.parent; int nSiblingIndex = gameObjects[0].transform.GetSiblingIndex(); GameObject go = new GameObject("Group"); Undo.RegisterCreatedObjectUndo(go, "CreateEmpty"); Undo.FlushUndoRecordObjects(); for (int i = 0; i < gameObjects.Length; i++) { GameObject gameObject = gameObjects[i]; Undo.SetTransformParent(gameObject.transform, go.transform, "Group"); } go.transform.SetParent(parent); go.transform.SetSiblingIndex(nSiblingIndex); EditorApplication.DirtyHierarchyWindowSorting(); EditorGUIUtility.PingObject(gameObjects[0]); }
public override void ResampleAnimation() { if (!this.state.disabled) { if (this.previewing) { if (this.canPreview) { if (this.state.activeAnimationClip != null) { AnimationMode.BeginSampling(); Undo.FlushUndoRecordObjects(); AnimationMode.SampleAnimationClip(this.state.activeRootGameObject, this.state.activeAnimationClip, this.time.time); if (this.m_CandidateClip != null) { AnimationMode.SampleCandidateClip(this.state.activeRootGameObject, this.m_CandidateClip, 0f); } AnimationMode.EndSampling(); SceneView.RepaintAll(); InspectorWindow.RepaintAllInspectors(); ParticleSystemWindow instance = ParticleSystemWindow.GetInstance(); if (instance) { instance.Repaint(); } } } } } }
public override void OnInspectorGUI() { GUILayout.Label(_logo); var transmitter = (VoiceBroadcastTrigger)target; ChannelTypeGui(transmitter); EditorGUILayout.Space(); PositionalAudioGui(transmitter); EditorGUILayout.Space(); PriorityGui(transmitter); EditorGUILayout.Space(); ActivationModeGui(transmitter); EditorGUILayout.Space(); _tokenEditor.DrawInspectorGui(transmitter, transmitter); EditorGUILayout.Space(); TriggerActivationGui(transmitter); Undo.FlushUndoRecordObjects(); EditorUtility.SetDirty(target); }
private void OnGUI() { // Add a Vertical Scrollview _scrollPosition = GUILayout.BeginScrollView(_scrollPosition); // Add a Title GUILayout.Label("VRSF Controllers Parameters", EditorStyles.boldLabel); // Add UseController toggle and record the event for Undo Undo.RecordObject(_controllersParameters, "Use Controller"); _controllersParameters.UseControllers = EditorGUILayout.Toggle("Use Controllers", _controllersParameters.UseControllers); EditorGUILayout.Space(); // if we use the controllers, we show the controllers parameters if (_controllersParameters.UseControllers) { ShowControllersParameters(); // Add a Reset parameters button for controller parameters if (GUILayout.Button("Reset Controllers Parameters to default")) { Undo.RecordObject(_controllersParameters, "Reset Controllers Parameters"); _controllersParameters.ResetParameters(); } } GUILayout.EndScrollView(); Undo.FlushUndoRecordObjects(); }