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