public IEnumerator CreateComposite_AddChildBrush_ChildHasCompositeAsParent()
{
var composite = TestUtility.CreateUndoableGameObjectWithComposite();
var compositeGameObject = composite.gameObject;
Assert.AreEqual(0, CSGManager.TreeBranchCount, "Expected 0 TreeBranches to Exist");
Assert.AreEqual(0, CSGManager.TreeBrushCount, "Expected 0 TreeBrushes to Exist");
Assert.AreEqual(0, CSGManager.TreeNodeCount, "Expected 0 TreeNodes to Exist");
yield return(null);
Assert.AreEqual(1, CSGManager.TreeBranchCount, "Expected 1 TreeBranch to Exist");
Assert.AreEqual(0, CSGManager.TreeBrushCount, "Expected 0 TreeBrushes to Exist");
Assert.AreEqual(2, CSGManager.TreeNodeCount, "Expected 2 TreeNodes to Exist");
var brush = TestUtility.CreateUndoableGameObjectWithBrush();
var brushGameObject = brush.gameObject;
Assert.AreEqual(CSGTreeNode.InvalidNode.NodeID, brush.TopNode.Parent.NodeID);
brush.transform.parent = composite.transform;
yield return(null);
Assert.True(compositeGameObject);
Assert.True(composite);
Assert.True(brushGameObject);
Assert.True(brush);
Assert.AreEqual(1, CSGManager.TreeBranchCount, "Expected 1 TreeBranch to Exist");
Assert.AreEqual(1, CSGManager.TreeBrushCount, "Expected 1 TreeBrush to Exist");
Assert.AreEqual(3, CSGManager.TreeNodeCount, "Expected 3 TreeNodes to Exist");
Assert.AreEqual(1, composite.Node.Count);
Assert.AreEqual(composite.Node.NodeID, brush.TopNode.Parent.NodeID);
}
public IEnumerator Model_AddChildComposite_ModelHasChild()
{
var model = TestUtility.CreateUndoableGameObjectWithModel();
var modelGameObject = model.gameObject;
var composite = TestUtility.CreateUndoableGameObjectWithComposite();
var compositeGameObject = composite.gameObject;
composite.transform.parent = model.transform;
Assert.AreEqual(0, CSGManager.TreeCount, "Expected 0 Trees to Exist");
Assert.AreEqual(0, CSGManager.TreeBranchCount, "Expected 0 TreeBranches to Exist");
Assert.AreEqual(0, CSGManager.TreeNodeCount, "Expected 0 TreeNodes to Exist");
yield return(null);
Assert.True(modelGameObject);
Assert.True(model);
Assert.True(compositeGameObject);
Assert.True(composite);
Assert.AreEqual(1, CSGManager.TreeCount, "Expected 1 Tree to Exist");
Assert.AreEqual(1, CSGManager.TreeBranchCount, "Expected 1 TreeBranch to Exist");
Assert.AreEqual(2, CSGManager.TreeNodeCount, "Expected 2 TreeNodes to Exist");
Assert.AreEqual(1, model.Node.Count);
Assert.AreEqual(composite.Node.NodeID, model.Node[0].NodeID);
}
public IEnumerator CompositeWithGameObject_AddChildBrush_CompositeHasChild()
{
var composite = TestUtility.CreateUndoableGameObjectWithComposite();
var compositeGameObject = composite.gameObject;
var plainGameObject = TestUtility.CreateGameObject();
plainGameObject.transform.parent = composite.transform;
var brush = TestUtility.CreateUndoableGameObjectWithBrush();
var brushGameObject = brush.gameObject;
brush.transform.parent = plainGameObject.transform;
Assert.AreEqual(0, CSGManager.TreeCount, "Expected 0 Trees to Exist");
Assert.AreEqual(0, CSGManager.TreeBrushCount, "Expected 0 TreeBrushes to Exist");
Assert.AreEqual(0, CSGManager.TreeNodeCount, "Expected 0 TreeNodes to Exist");
yield return(null);
Assert.True(compositeGameObject);
Assert.True(composite);
Assert.True(brushGameObject);
Assert.True(brush);
Assert.AreEqual(1, CSGManager.TreeBranchCount, "Expected 1 TreeBranch to Exist");
Assert.AreEqual(1, CSGManager.TreeBrushCount, "Expected 1 TreeBrush to Exist");
Assert.AreEqual(3, CSGManager.TreeNodeCount, "Expected 3 TreeNodes to Exist");
Assert.AreEqual(1, composite.Node.Count);
Assert.AreEqual(brush.TopNode.NodeID, composite.Node[0].NodeID);
}
public IEnumerator CompositeWithGameObject_AddChildComposite_CompositeHasChild()
{
var composite1 = TestUtility.CreateUndoableGameObjectWithComposite();
var composite1GameObject = composite1.gameObject;
var plainGameObject = TestUtility.CreateGameObject();
plainGameObject.transform.parent = composite1.transform;
var composite2 = TestUtility.CreateUndoableGameObjectWithComposite();
var composite2GameObject = composite2.gameObject;
composite2.transform.parent = plainGameObject.transform;
Assert.AreEqual(0, CSGManager.TreeCount, "Expected 0 Trees to Exist");
Assert.AreEqual(0, CSGManager.TreeBranchCount, "Expected 0 TreeBranches to Exist");
Assert.AreEqual(0, CSGManager.TreeNodeCount, "Expected 0 TreeNodes to Exist");
yield return(null);
Assert.True(composite1GameObject);
Assert.True(composite1);
Assert.True(composite2GameObject);
Assert.True(composite2);
Assert.AreEqual(2, CSGManager.TreeBranchCount, "Expected 2 TreeBranches to Exist");
Assert.AreEqual(3, CSGManager.TreeNodeCount, "Expected 3 TreeNodes to Exist");
Assert.AreEqual(1, composite1.Node.Count);
Assert.AreEqual(composite2.Node.NodeID, composite1.Node[0].NodeID);
}
public IEnumerator DisabledCompositeWithPassThroughEnabled_EnableCompositeComponent_CompositeDoesNotExist()
{
var scene = TestUtility.defaultScene;
var composite = TestUtility.CreateUndoableGameObjectWithComposite();
var compositeGameObject = composite.gameObject;
composite.enabled = false;
composite.PassThrough = true;
Assert.AreEqual(0, CSGManager.TreeBranchCount, "Expected 0 TreeBranches to Exist");
Assert.AreEqual(0, CSGManager.TreeNodeCount, "Expected 0 TreeNodes to Exist");
yield return(null);
Assert.AreEqual(0, CSGManager.TreeBranchCount, "Expected 0 TreeBranches to Exist");
Assert.AreEqual(0, CSGManager.TreeNodeCount, "Expected 0 TreeNodes to Exist");
composite.enabled = true;
yield return(null);
Assert.True(compositeGameObject);
Assert.True(composite);
Assert.AreEqual(composite.Node, (CSGTreeBranch)CSGTreeNode.InvalidNode);
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));
}
public IEnumerator Composite1WithDisabledComposite2_AddChildComposite_ChildHasParentOfCompositeAsParent()
{
var composite1 = TestUtility.CreateUndoableGameObjectWithComposite();
var composite1GameObject = composite1.gameObject;
var composite2 = TestUtility.CreateUndoableGameObjectWithComposite();
var composite2GameObject = composite2.gameObject;
composite2.transform.parent = composite1.transform;
composite2.enabled = false;
var composite3 = TestUtility.CreateUndoableGameObjectWithComposite();
var composite3GameObject = composite3.gameObject;
composite3.transform.parent = composite2.transform;
Assert.True(composite1GameObject);
Assert.True(composite1);
Assert.True(composite2GameObject);
Assert.True(composite2);
Assert.True(composite3GameObject);
Assert.True(composite3);
Assert.AreEqual(0, CSGManager.TreeBranchCount, "Expected 0 TreeBranches to Exist");
Assert.AreEqual(0, CSGManager.TreeBrushCount, "Expected 0 TreeBrushes to Exist");
Assert.AreEqual(0, CSGManager.TreeNodeCount, "Expected 0 TreeNodes to Exist");
yield return(null);
Assert.AreEqual(2, CSGManager.TreeBranchCount, "Expected 2 TreeBranches to Exist");
Assert.AreEqual(3, CSGManager.TreeNodeCount, "Expected 3 TreeNodes to Exist");
Assert.AreEqual(1, composite1.Node.Count);
Assert.AreEqual(CSGTreeNode.InvalidNode.NodeID, composite2.Node.NodeID);
Assert.AreEqual(composite1.Node.NodeID, composite3.Node.Parent.NodeID);
}
public IEnumerator CompositeWithPassThroughEnabled_DestroyCompositeComponent_CompositeDoesNotExist()
{
var scene = TestUtility.defaultScene;
var composite = TestUtility.CreateUndoableGameObjectWithComposite();
var compositeGameObject = composite.gameObject;
composite.PassThrough = true;
Assert.AreEqual(0, CSGManager.TreeBranchCount, "Expected 0 TreeBranches to Exist");
Assert.AreEqual(0, CSGManager.TreeNodeCount, "Expected 0 TreeNodes to Exist");
yield return(null);
Assert.AreEqual(0, CSGManager.TreeBranchCount, "Expected 0 TreeBranches to Exist");
Assert.AreEqual(0, CSGManager.TreeNodeCount, "Expected 0 TreeNodes to Exist");
Assert.True(compositeGameObject);
Assert.True(composite);
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));
}
public IEnumerator CompositeWithChildBrush_DisableAndEnableCompositeComponent_ChildHasCompositeAsParent()
{
var composite = TestUtility.CreateUndoableGameObjectWithComposite();
var compositeGameObject = composite.gameObject;
var brush = TestUtility.CreateUndoableGameObjectWithBrush();
var brushGameObject = brush.gameObject;
brush.transform.parent = composite.transform;
yield return(null);
composite.enabled = false;
yield return(null);
composite.enabled = true;
yield return(null);
Assert.AreEqual(1, CSGManager.TreeBranchCount, "Expected 1 TreeBranch to Exist");
Assert.AreEqual(1, CSGManager.TreeBrushCount, "Expected 1 TreeBrush to Exist");
Assert.AreEqual(3, CSGManager.TreeNodeCount, "Expected 3 TreeNodes to Exist");
Assert.AreEqual(1, composite.Node.Count);
Assert.AreEqual(composite.Node.NodeID, brush.TopNode.Parent.NodeID);
}
public IEnumerator CreateComposite_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 composite = TestUtility.CreateUndoableGameObjectWithComposite();
var compositeGameObject = composite.gameObject;
Assert.AreEqual(compositeGameObject.scene, newScene);
Assert.True(newScene.isDirty);
Assert.False(currentScene.isDirty);
Undo.PerformUndo();
yield return(null);
Assert.False(compositeGameObject);
Assert.False(composite);
Assert.False(newScene.isDirty);
Assert.False(currentScene.isDirty);
}
public IEnumerator CreateAndDestroyCompositeGameObject_Undo_CompositeExists()
{
var scene = TestUtility.defaultScene;
var composite = TestUtility.CreateUndoableGameObjectWithComposite();
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(compositeGameObject);
yield return(null);
Assert.False(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 = Object.FindObjectsOfType <ChiselComposite>()[0];
compositeGameObject = composite.gameObject;
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));
}
public IEnumerator Composite1WithDisabledComposite2WithChildBrush_EnableComposite2_ChildHasComposite2AsParent()
{
var composite1 = TestUtility.CreateUndoableGameObjectWithComposite("composite1");
var composite1GameObject = composite1.gameObject;
var composite2 = TestUtility.CreateUndoableGameObjectWithComposite("composite2");
var composite2GameObject = composite2.gameObject;
composite2.transform.parent = composite1.transform;
composite2.enabled = false;
var brush = TestUtility.CreateUndoableGameObjectWithBrush();
var brushGameObject = brush.gameObject;
brush.transform.parent = composite2.transform;
Assert.True(composite1GameObject);
Assert.True(composite1);
Assert.True(composite2GameObject);
Assert.True(composite2);
Assert.True(brushGameObject);
Assert.True(brush);
Assert.AreEqual(0, CSGManager.TreeBranchCount, "Expected 0 TreeBranches to Exist");
Assert.AreEqual(0, CSGManager.TreeBrushCount, "Expected 0 TreeBrushes to Exist");
Assert.AreEqual(0, CSGManager.TreeNodeCount, "Expected 0 TreeNodes to Exist");
yield return(null);
Assert.AreEqual(1, CSGManager.TreeBranchCount, "Expected 1 TreeBranch to Exist");
Assert.AreEqual(1, CSGManager.TreeBrushCount, "Expected 1 TreeBrush to Exist");
Assert.AreEqual(3, CSGManager.TreeNodeCount, "Expected 3 TreeNodes to Exist");
Assert.AreEqual(1, composite1.Node.Count);
Assert.AreNotEqual(CSGTreeNode.InvalidNode.NodeID, brush.TopNode.NodeID);
Assert.AreEqual(CSGTreeNode.InvalidNode.NodeID, composite2.Node.NodeID);
Assert.AreEqual(composite1.Node.NodeID, brush.TopNode.Parent.NodeID);
composite2.enabled = true;
yield return(null);
Assert.AreEqual(2, CSGManager.TreeBranchCount, "Expected 2 TreeBranches to Exist");
Assert.AreEqual(1, CSGManager.TreeBrushCount, "Expected 1 TreeBrush to Exist");
Assert.AreEqual(4, CSGManager.TreeNodeCount, "Expected 4 TreeNodes to Exist");
Assert.AreNotEqual(CSGTreeNode.InvalidNode.NodeID, composite2.Node.NodeID);
Assert.AreNotEqual(CSGTreeNode.InvalidNode.NodeID, brush.TopNode.NodeID);
Assert.AreEqual(composite2.Node.NodeID, brush.TopNode.Parent.NodeID);
Assert.AreEqual(composite1.Node.NodeID, composite2.Node.Parent.NodeID);
Assert.AreEqual(1, composite1.Node.Count);
Assert.AreEqual(1, composite2.Node.Count);
}
public IEnumerator CompositeWithChildInScene1_MoveToScene2_CompositeWithChildOnlyExistsInScene2()
{
var scene2 = TestUtility.defaultScene;
EditorSceneManager.SaveScene(scene2, TestUtility.tempFilename);
var scene1 = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Additive);
EditorSceneManager.SetActiveScene(scene1);
var composite = TestUtility.CreateUndoableGameObjectWithComposite();
var compositeGameObject = composite.gameObject;
var brush = TestUtility.CreateUndoableGameObjectWithBrush();
var brushGameObject = brush.gameObject;
brush.transform.parent = composite.transform;
Assert.AreEqual(0, CSGManager.TreeBranchCount, "Expected 0 TreeBranches to Exist");
Assert.AreEqual(0, CSGManager.TreeBrushCount, "Expected 0 TreeBrushes to Exist");
Assert.AreEqual(0, CSGManager.TreeNodeCount, "Expected 0 TreeNodes to Exist");
yield return(null);
Assert.AreEqual(1, CSGManager.TreeBranchCount, "Expected 1 TreeBranch to Exist");
Assert.AreEqual(1, CSGManager.TreeBrushCount, "Expected 1 TreeBrush to Exist");
Assert.AreEqual(3, CSGManager.TreeNodeCount, "Expected 3 TreeNodes to Exist");
Assert.AreEqual(scene1, composite.gameObject.scene);
Assert.AreEqual(scene1, composite.hierarchyItem.Scene);
Undo.MoveGameObjectToScene(compositeGameObject, scene2, "Move gameObject to different scene");
yield return(null);
Assert.AreEqual(1, CSGManager.TreeBranchCount, "Expected 1 TreeBranch to Exist");
Assert.AreEqual(1, CSGManager.TreeBrushCount, "Expected 1 TreeBrush to Exist");
Assert.AreEqual(3, CSGManager.TreeNodeCount, "Expected 3 TreeNodes to Exist");
Assert.AreEqual(composite.hierarchyItem, brush.hierarchyItem.Parent);
Assert.AreEqual(composite.NodeID, brush.hierarchyItem.Parent.Component.NodeID);
Assert.AreEqual(composite.NodeID, brush.TopNode.Parent.NodeID);
Assert.AreEqual(scene2, composite.gameObject.scene, "Composite is not part of expected scene");
Assert.AreEqual(scene2, composite.hierarchyItem.Scene, "Composite is not registered to expected scene");
Assert.AreEqual(scene2, brush.gameObject.scene, "Brush is not part of expected scene");
Assert.AreEqual(scene2, brush.hierarchyItem.Scene, "Brush is not registered to expected scene");
Assert.AreEqual(0, ChiselNodeHierarchyManager.RootCount(scene1));
Assert.AreEqual(1, ChiselNodeHierarchyManager.RootCount(scene2));
// make sure test runner doesn't puke on its own bugs
EditorSceneManager.NewScene(NewSceneSetup.EmptyScene);
}
public IEnumerator Composite1WithChildBrush_MoveBrushToNoneChiselNodeChildOfComposite2_ChildHasComposite2AsParent()
{
var composite1 = TestUtility.CreateUndoableGameObjectWithComposite("composite1");
var composite1GameObject = composite1.gameObject;
var composite2 = TestUtility.CreateUndoableGameObjectWithComposite("composite2");
var composite2GameObject = composite2.gameObject;
var plainGameObject = TestUtility.CreateGameObject("gameObject");
plainGameObject.transform.parent = composite2.transform;
var brush = TestUtility.CreateUndoableGameObjectWithBrush();
var brushGameObject = brush.gameObject;
brush.transform.parent = composite1.transform;
Assert.True(composite1GameObject);
Assert.True(composite1);
Assert.True(composite2GameObject);
Assert.True(composite2);
Assert.True(brushGameObject);
Assert.True(brush);
Assert.AreEqual(0, CSGManager.TreeBranchCount, "Expected 0 TreeBranches to Exist");
Assert.AreEqual(0, CSGManager.TreeBrushCount, "Expected 0 TreeBrushes to Exist");
Assert.AreEqual(0, CSGManager.TreeNodeCount, "Expected 0 TreeNodes to Exist");
yield return(null);
Assert.AreEqual(2, CSGManager.TreeBranchCount, "Expected 2 TreeBranches to Exist");
Assert.AreEqual(1, CSGManager.TreeBrushCount, "Expected 1 TreeBrush to Exist");
Assert.AreEqual(4, CSGManager.TreeNodeCount, "Expected 4 TreeNodes to Exist");
Assert.AreNotEqual(CSGTreeNode.InvalidNode.NodeID, composite2.Node.NodeID);
Assert.AreNotEqual(CSGTreeNode.InvalidNode.NodeID, composite1.Node.NodeID);
Assert.AreNotEqual(CSGTreeNode.InvalidNode.NodeID, brush.TopNode.NodeID);
Assert.AreEqual(composite1.Node.NodeID, brush.TopNode.Parent.NodeID);
Assert.AreEqual(1, composite1.Node.Count);
Assert.AreEqual(0, composite2.Node.Count);
brush.transform.parent = plainGameObject.transform;
yield return(null);
Assert.AreEqual(composite2.Node.NodeID, brush.TopNode.Parent.NodeID);
Assert.AreEqual(0, composite1.Node.Count);
Assert.AreEqual(1, composite2.Node.Count);
}
public IEnumerator Composite1WithWithGameObjectWithBrush_AddComposite2ToGameObject_BrushHasComposite2AsParent()
{
var composite1 = TestUtility.CreateUndoableGameObjectWithComposite("composite1");
var composite1GameObject = composite1.gameObject;
var composite2GameObject = TestUtility.CreateGameObject("composite2");
composite2GameObject.transform.parent = composite1GameObject.transform;
var brush = TestUtility.CreateUndoableGameObjectWithBrush("brush");
var brushGameObject = brush.gameObject;
brush.transform.parent = composite2GameObject.transform;
Assert.AreEqual(0, CSGManager.TreeBranchCount, "Expected 0 TreeBranches to Exist");
Assert.AreEqual(0, CSGManager.TreeBrushCount, "Expected 0 TreeBrushes to Exist");
Assert.AreEqual(0, CSGManager.TreeNodeCount, "Expected 0 TreeNodes to Exist");
yield return(null);
Assert.True(composite1GameObject);
Assert.True(composite1);
Assert.True(composite2GameObject);
Assert.True(brushGameObject);
Assert.True(brush);
Assert.AreEqual(1, CSGManager.TreeBranchCount, "Expected 1 TreeBranch to Exist");
Assert.AreEqual(1, CSGManager.TreeBrushCount, "Expected 1 TreeBrush to Exist");
Assert.AreEqual(3, CSGManager.TreeNodeCount, "Expected 3 TreeNodes to Exist");
Assert.AreEqual(1, composite1.Node.Count);
Assert.AreEqual(composite1.Node.NodeID, brush.TopNode.Parent.NodeID);
var composite2 = TestUtility.CreateUndoableCompositeComponent(composite2GameObject);
yield return(null);
Assert.True(composite1GameObject);
Assert.True(composite1);
Assert.True(composite2GameObject);
Assert.True(composite2);
Assert.True(brushGameObject);
Assert.True(brush);
Assert.AreEqual(2, CSGManager.TreeBranchCount, "Expected 2 TreeBranches to Exist");
Assert.AreEqual(1, CSGManager.TreeBrushCount, "Expected 1 TreeBrush to Exist");
Assert.AreEqual(4, CSGManager.TreeNodeCount, "Expected 4 TreeNodes to Exist");
Assert.AreEqual(1, composite2.Node.Count);
Assert.AreEqual(1, composite1.Node.Count);
Assert.AreEqual(composite1.Node.NodeID, composite2.Node.Parent.NodeID);
Assert.AreEqual(composite2.Node.NodeID, brush.TopNode.Parent.NodeID);
}
public void CreateComposite_OnlyDirtiesSceneOfComposite()
{
var currentScene = SceneManager.GetActiveScene();
var newScene = TestUtility.CreateAdditionalSceneAndActivate();
Assert.False(currentScene.isDirty);
Assert.False(newScene.isDirty);
var composite = TestUtility.CreateUndoableGameObjectWithComposite();
var compositeGameObject = composite.gameObject;
Assert.AreEqual(newScene, compositeGameObject.scene);
Assert.True(newScene.isDirty);
Assert.False(currentScene.isDirty);
}
public IEnumerator Composite1WithComposite2WithChildBrush_DestroyCompositeComponent2_ChildHasComposite1AsParent()
{
var composite1 = TestUtility.CreateUndoableGameObjectWithComposite();
var composite1GameObject = composite1.gameObject;
var composite2 = TestUtility.CreateUndoableGameObjectWithComposite();
var composite2GameObject = composite2.gameObject;
composite2.transform.parent = composite1.transform;
var brush = TestUtility.CreateUndoableGameObjectWithBrush();
var brushGameObject = brush.gameObject;
brush.transform.parent = composite2.transform;
Assert.True(composite1GameObject);
Assert.True(composite1);
Assert.True(composite2GameObject);
Assert.True(composite2);
Assert.True(brushGameObject);
Assert.True(brush);
Assert.AreEqual(0, CSGManager.TreeBranchCount, "Expected 0 TreeBranches to Exist");
Assert.AreEqual(0, CSGManager.TreeBrushCount, "Expected 0 TreeBrushes to Exist");
Assert.AreEqual(0, CSGManager.TreeNodeCount, "Expected 0 TreeNodes to Exist");
yield return(null);
Assert.AreEqual(2, CSGManager.TreeBranchCount, "Expected 2 TreeBranches to Exist");
Assert.AreEqual(1, CSGManager.TreeBrushCount, "Expected 1 TreeBrush to Exist");
Assert.AreEqual(4, CSGManager.TreeNodeCount, "Expected 4 TreeNodes to Exist");
Assert.AreEqual(1, composite1.Node.Count);
Assert.AreEqual(1, composite2.Node.Count);
Assert.AreEqual(composite2.Node.NodeID, brush.TopNode.Parent.NodeID);
Assert.AreEqual(composite1.Node.NodeID, composite2.Node.Parent.NodeID);
Undo.DestroyObjectImmediate(composite2);
yield return(null);
Assert.False(composite2);
Assert.AreEqual(1, CSGManager.TreeBranchCount, "Expected 1 TreeBranch to Exist");
Assert.AreEqual(1, CSGManager.TreeBrushCount, "Expected 1 TreeBrush to Exist");
Assert.AreEqual(3, CSGManager.TreeNodeCount, "Expected 3 TreeNodes to Exist");
Assert.AreEqual(1, composite1.Node.Count);
Assert.AreEqual(composite1.Node.NodeID, brush.TopNode.Parent.NodeID);
}
public IEnumerator CompositeWithTwoChildBrushes_SwapOrder_CompositeHasChildrenInOrder()
{
var composite = TestUtility.CreateUndoableGameObjectWithComposite();
var compositeGameObject = composite.gameObject;
var brush1 = TestUtility.CreateUndoableGameObjectWithBrush();
var brush1GameObject = brush1.gameObject;
brush1.transform.parent = composite.transform;
var brush2 = TestUtility.CreateUndoableGameObjectWithBrush();
var brush2GameObject = brush2.gameObject;
brush2.transform.parent = composite.transform;
Assert.AreEqual(0, CSGManager.TreeCount, "Expected 0 Trees to Exist");
Assert.AreEqual(0, CSGManager.TreeBrushCount, "Expected 0 TreeBrushes to Exist");
Assert.AreEqual(0, CSGManager.TreeNodeCount, "Expected 0 TreeNodes to Exist");
Assert.True(compositeGameObject);
Assert.True(composite);
Assert.True(brush1GameObject);
Assert.True(brush1);
Assert.True(brush2GameObject);
Assert.True(brush2);
Assert.AreEqual(composite.transform.GetChild(0), brush1.transform);
Assert.AreEqual(composite.transform.GetChild(1), brush2.transform);
yield return(null);
Assert.AreEqual(1, CSGManager.TreeBranchCount, "Expected 1 TreeBranch to Exist");
Assert.AreEqual(2, CSGManager.TreeBrushCount, "Expected 2 TreeBrushes to Exist");
Assert.AreEqual(4, CSGManager.TreeNodeCount, "Expected 4 TreeNodes to Exist");
Assert.AreEqual(2, composite.Node.Count);
brush2.transform.SetSiblingIndex(0);
Assert.AreEqual(composite.transform.GetChild(0), brush2.transform);
Assert.AreEqual(composite.transform.GetChild(1), brush1.transform);
yield return(null);
Assert.AreEqual(brush2.TopNode.NodeID, composite.Node[0].NodeID);
Assert.AreEqual(brush1.TopNode.NodeID, composite.Node[1].NodeID);
}
public IEnumerator GameObjectInScene1WithComposite_MoveCompositeToGameObjectInScene2_CompositeOnlyExistsInScene2()
{
var scene2 = TestUtility.defaultScene;
var scene2GameObject = new GameObject();
EditorSceneManager.SaveScene(scene2, TestUtility.tempFilename);
var scene1 = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Additive);
EditorSceneManager.SetActiveScene(scene1);
var scene1GameObject = new GameObject();
var composite = TestUtility.CreateUndoableGameObjectWithComposite();
var compositeGameObject = composite.gameObject;
composite.transform.parent = scene1GameObject.transform;
Assert.AreEqual(0, CSGManager.TreeBranchCount, "Expected 0 TreeBranches to Exist");
Assert.AreEqual(0, CSGManager.TreeNodeCount, "Expected 0 TreeNodes to Exist");
yield return(null);
Assert.AreEqual(1, CSGManager.TreeBranchCount, "Expected 1 TreeBranch to Exist");
Assert.AreEqual(2, CSGManager.TreeNodeCount, "Expected 2 TreeNodes to Exist");
Assert.AreEqual(scene1, composite.hierarchyItem.Scene);
composite.transform.parent = scene2GameObject.transform;
yield return(null);
Assert.AreEqual(1, CSGManager.TreeBranchCount, "Expected 1 TreeBranch to Exist");
Assert.AreEqual(2, CSGManager.TreeNodeCount, "Expected 2 TreeNodes to Exist");
Assert.AreEqual(scene2, composite.gameObject.scene, "Composite is not part of expected scene");
Assert.AreEqual(scene2, composite.hierarchyItem.Scene, "Composite is not registered to expected scene");
Assert.AreEqual(0, ChiselNodeHierarchyManager.RootCount(scene1));
Assert.AreEqual(1, ChiselNodeHierarchyManager.RootCount(scene2));
// make sure test runner doesn't puke on its own bugs
EditorSceneManager.NewScene(NewSceneSetup.EmptyScene);
}
public IEnumerator CompositeWithChildBrush_DestroyComposite_ChildIsDestroyed()
{
var scene = TestUtility.defaultScene;
var composite = TestUtility.CreateUndoableGameObjectWithComposite();
var compositeGameObject = composite.gameObject;
var brush = TestUtility.CreateUndoableGameObjectWithBrush();
var brushGameObject = brush.gameObject;
brush.transform.parent = composite.transform;
Assert.True(compositeGameObject);
Assert.True(composite);
Assert.True(brushGameObject);
Assert.True(brush);
Assert.AreEqual(0, CSGManager.TreeBranchCount, "Expected 0 TreeBranches to Exist");
Assert.AreEqual(0, CSGManager.TreeBrushCount, "Expected 0 TreeBrushes to Exist");
Assert.AreEqual(0, CSGManager.TreeNodeCount, "Expected 0 TreeNodes to Exist");
yield return(null);
Assert.AreEqual(1, CSGManager.TreeBranchCount, "Expected 1 TreeBranch to Exist");
Assert.AreEqual(1, CSGManager.TreeBrushCount, "Expected 1 TreeBrush to Exist");
Assert.AreEqual(3, CSGManager.TreeNodeCount, "Expected 3 TreeNodes to Exist");
Assert.AreEqual(1, composite.Node.Count, 1);
Assert.AreEqual(composite.Node.NodeID, brush.TopNode.Parent.NodeID);
Undo.DestroyObjectImmediate(compositeGameObject);
yield return(null);
Assert.False(compositeGameObject);
Assert.False(composite);
Assert.False(brushGameObject);
Assert.False(brush);
Assert.AreEqual(0, CSGManager.TreeBranchCount, "Expected 0 TreeBranches to Exist");
Assert.AreEqual(0, CSGManager.TreeBrushCount, "Expected 0 TreeBrushes to Exist");
Assert.AreEqual(0, CSGManager.TreeNodeCount, "Expected 0 TreeNodes to Exist");
Assert.AreEqual(0, ChiselNodeHierarchyManager.RootCount(scene));
}
public IEnumerator CreateComposite_DisableCompositeComponent_CompositeDoesNotExist()
{
var scene = TestUtility.defaultScene;
var composite = TestUtility.CreateUndoableGameObjectWithComposite();
var compositeGameObject = composite.gameObject;
Assert.AreEqual(0, CSGManager.TreeBranchCount, "Expected 0 TreeBranches to Exist");
Assert.AreEqual(0, CSGManager.TreeNodeCount, "Expected 0 TreeNodes to Exist");
yield return(null);
Assert.AreEqual(1, CSGManager.TreeBranchCount, "Expected 1 TreeBranch to Exist");
Assert.AreEqual(2, CSGManager.TreeNodeCount, "Expected 2 TreeNodes to Exist");
composite.enabled = false;
yield return(null);
Assert.True(compositeGameObject);
Assert.True(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));
}
public IEnumerator CompositeWithChildBrush_DeactivateChildGameObject_CompositeHasNoChildren()
{
var composite = TestUtility.CreateUndoableGameObjectWithComposite();
var compositeGameObject = composite.gameObject;
var brush = TestUtility.CreateUndoableGameObjectWithBrush();
var brushGameObject = brush.gameObject;
brush.transform.parent = composite.transform;
Assert.AreEqual(0, CSGManager.TreeBranchCount, "Expected 0 TreeBranches to Exist");
Assert.AreEqual(0, CSGManager.TreeBrushCount, "Expected 0 TreeBrushes to Exist");
Assert.AreEqual(0, CSGManager.TreeNodeCount, "Expected 0 TreeNodes to Exist");
yield return(null);
Assert.True(compositeGameObject);
Assert.True(composite);
Assert.True(brushGameObject);
Assert.True(brush);
Assert.AreEqual(1, CSGManager.TreeBranchCount, "Expected 1 TreeBranch to Exist");
Assert.AreEqual(1, CSGManager.TreeBrushCount, "Expected 1 TreeBrush to Exist");
Assert.AreEqual(3, CSGManager.TreeNodeCount, "Expected 3 TreeNodes to Exist");
Assert.AreEqual(1, composite.Node.Count);
Assert.AreEqual(composite.Node.NodeID, brush.TopNode.Parent.NodeID);
brushGameObject.SetActive(false);
yield return(null);
Assert.True(compositeGameObject);
Assert.True(composite);
Assert.True(brushGameObject);
Assert.True(brush);
Assert.AreEqual(1, CSGManager.TreeBranchCount, "Expected 1 TreeBranch to Exist");
Assert.AreEqual(0, CSGManager.TreeBrushCount, "Expected 0 TreeBrushes to Exist");
Assert.AreEqual(2, CSGManager.TreeNodeCount, "Expected 2 TreeNodes to Exist");
Assert.AreEqual(0, composite.Node.Count);
}
public IEnumerator ModelWithChildComposite_DestroyChildGameObject_ModelHasNoChildren()
{
var model = TestUtility.CreateUndoableGameObjectWithModel();
var modelameObject = model.gameObject;
var composite = TestUtility.CreateUndoableGameObjectWithComposite();
var compositeGameObject = composite.gameObject;
composite.transform.parent = model.transform;
Assert.AreEqual(0, CSGManager.TreeCount, "Expected 0 Trees to Exist");
Assert.AreEqual(0, CSGManager.TreeBranchCount, "Expected 0 TreeBranches to Exist");
Assert.AreEqual(0, CSGManager.TreeNodeCount, "Expected 0 TreeNodes to Exist");
yield return(null);
Assert.True(modelameObject);
Assert.True(model);
Assert.True(compositeGameObject);
Assert.True(composite);
Assert.AreEqual(1, CSGManager.TreeCount, "Expected 1 Tree to Exist");
Assert.AreEqual(1, CSGManager.TreeBranchCount, "Expected 1 TreeBranch to Exist");
Assert.AreEqual(2, CSGManager.TreeNodeCount, "Expected 2 TreeNodes to Exist");
Assert.AreEqual(1, model.Node.Count);
Assert.AreEqual(model.Node.NodeID, composite.Node.Tree.NodeID);
Undo.DestroyObjectImmediate(compositeGameObject);
yield return(null);
Assert.True(modelameObject);
Assert.True(model);
Assert.False(compositeGameObject);
Assert.False(composite);
Assert.AreEqual(1, CSGManager.TreeCount, "Expected 1 Tree to Exist");
Assert.AreEqual(0, CSGManager.TreeBranchCount, "Expected 0 TreeBranches to Exist");
Assert.AreEqual(1, CSGManager.TreeNodeCount, "Expected 1 TreeNode to Exist");
Assert.AreEqual(0, model.Node.Count);
}
public IEnumerator Composite1WithComposite2WithChildBrush_DeactivateComposite2GameObject_ChildIsAlsoDeactivated()
{
var scene = TestUtility.defaultScene;
var composite1 = TestUtility.CreateUndoableGameObjectWithComposite();
var composite1GameObject = composite1.gameObject;
var composite2 = TestUtility.CreateUndoableGameObjectWithComposite();
var composite2GameObject = composite2.gameObject;
composite2.transform.parent = composite1.transform;
composite2GameObject.SetActive(false);
var brush = TestUtility.CreateUndoableGameObjectWithBrush();
var brushGameObject = brush.gameObject;
brush.transform.parent = composite2.transform;
Assert.True(composite1GameObject);
Assert.True(composite1);
Assert.True(composite2GameObject);
Assert.True(composite2);
Assert.True(brushGameObject);
Assert.True(brush);
Assert.AreEqual(0, CSGManager.TreeBranchCount, "Expected 0 TreeBranches to Exist");
Assert.AreEqual(0, CSGManager.TreeBrushCount, "Expected 0 TreeBrushes to Exist");
Assert.AreEqual(0, CSGManager.TreeNodeCount, "Expected 0 TreeNodes to Exist");
yield return(null);
Assert.AreEqual(1, CSGManager.TreeBranchCount, "Expected 1 TreeBranch to Exist");
Assert.AreEqual(0, CSGManager.TreeBrushCount, "Expected 0 TreeBrushes to Exist");
Assert.AreEqual(2, CSGManager.TreeNodeCount, "Expected 2 TreeNodes to Exist");
Assert.AreEqual(0, composite1.Node.Count);
Assert.AreEqual(CSGTreeNode.InvalidNode.NodeID, brush.TopNode.NodeID);
Assert.AreEqual(CSGTreeNode.InvalidNode.NodeID, composite2.Node.NodeID);
Assert.AreEqual(1, ChiselNodeHierarchyManager.RootCount(scene));
}
public IEnumerator CreateComposite_DestroyCompositeComponent_OnlyDirtiesSceneOfComposite()
{
var currentScene = SceneManager.GetActiveScene();
var newScene = TestUtility.CreateAdditionalSceneAndActivate();
Assert.False(currentScene.isDirty);
Assert.False(newScene.isDirty);
var composite = TestUtility.CreateUndoableGameObjectWithComposite();
var compositeGameObject = composite.gameObject;
Assert.AreEqual(newScene, compositeGameObject.scene);
Assert.True(newScene.isDirty);
Assert.False(currentScene.isDirty);
Undo.DestroyObjectImmediate(composite);
yield return(null);
Assert.True(compositeGameObject);
Assert.False(composite);
Assert.True(newScene.isDirty);
Assert.False(currentScene.isDirty);
}
public IEnumerator SaveCompositeInScene_LoadScene_CompositeTreeNodeIsGenerated()
{
var scene1 = TestUtility.defaultScene;
{
TestUtility.CreateUndoableGameObjectWithComposite();
EditorSceneManager.SaveScene(scene1, TestUtility.tempFilename);
}
var scene2 = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene);
yield return(null);
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(scene2));
var scene3 = EditorSceneManager.OpenScene(TestUtility.tempFilename);
var composites = Object.FindObjectsOfType <ChiselComposite>();
yield return(null);
Assert.NotNull(composites);
Assert.AreEqual(1, composites.Length);
Assert.AreEqual(1, CSGManager.TreeBranchCount, "Expected 1 TreeBranch to Exist");
Assert.AreEqual(2, CSGManager.TreeNodeCount, "Expected 2 TreeNodes to Exist");
Assert.AreEqual(scene3, composites[0].gameObject.scene, "Composite is not part of expected scene");
Assert.AreEqual(scene3, composites[0].hierarchyItem.Scene, "Composite is not registered to expected scene");
Assert.AreEqual(0, ChiselNodeHierarchyManager.RootCount(scene1)); // unloaded, so should be unknown to us
Assert.AreEqual(0, ChiselNodeHierarchyManager.RootCount(scene2)); // unloaded, so should be unknown to us
Assert.AreEqual(1, ChiselNodeHierarchyManager.RootCount(scene3));
// make sure test runner doesn't puke on its own bugs
EditorSceneManager.NewScene(NewSceneSetup.EmptyScene);
}
public IEnumerator Composite1WithPassthroughComposite2_AddChild_ChildHasComposite1AsParent()
{
var composite1 = TestUtility.CreateUndoableGameObjectWithComposite();
var composite1GameObject = composite1.gameObject;
var composite2 = TestUtility.CreateUndoableGameObjectWithComposite();
var composite2GameObject = composite2.gameObject;
composite2.transform.parent = composite1.transform;
composite2.PassThrough = true;
var brush = TestUtility.CreateUndoableGameObjectWithBrush();
var brushGameObject = brush.gameObject;
brush.transform.parent = composite2.transform;
Assert.True(composite1GameObject);
Assert.True(composite1);
Assert.True(composite2GameObject);
Assert.True(composite2);
Assert.True(brushGameObject);
Assert.True(brush);
Assert.AreEqual(0, CSGManager.TreeBranchCount, "Expected 0 TreeBranches to Exist");
Assert.AreEqual(0, CSGManager.TreeBrushCount, "Expected 0 TreeBrushes to Exist");
Assert.AreEqual(0, CSGManager.TreeNodeCount, "Expected 0 TreeNodes to Exist");
yield return(null);
Assert.AreEqual(1, CSGManager.TreeBranchCount, "Expected 1 TreeBranch to Exist");
Assert.AreEqual(1, CSGManager.TreeBrushCount, "Expected 1 TreeBrush to Exist");
Assert.AreEqual(3, CSGManager.TreeNodeCount, "Expected 3 TreeNodes to Exist");
Assert.AreEqual(brush.TopNode.Parent, composite1.Node);
Assert.AreEqual(composite1.Node.Count, 1);
Assert.AreEqual(composite2.Node, (CSGTreeBranch)CSGTreeNode.InvalidNode);
}
public IEnumerator CompositeWithChildComposite_DeactivateChildGameObject_CompositeHasNoChildren()
{
var composite1 = TestUtility.CreateUndoableGameObjectWithComposite();
var composite1GameObject = composite1.gameObject;
var composite2 = TestUtility.CreateUndoableGameObjectWithComposite();
var composite2GameObject = composite2.gameObject;
composite2.transform.parent = composite1.transform;
Assert.AreEqual(0, CSGManager.TreeBranchCount, "Expected 0 TreeBranches to Exist");
Assert.AreEqual(0, CSGManager.TreeNodeCount, "Expected 0 TreeNodes to Exist");
yield return(null);
Assert.True(composite1GameObject);
Assert.True(composite1);
Assert.True(composite2GameObject);
Assert.True(composite2);
Assert.AreEqual(2, CSGManager.TreeBranchCount, "Expected 2 TreeBranches to Exist");
Assert.AreEqual(3, CSGManager.TreeNodeCount, "Expected 3 TreeNodes to Exist");
Assert.AreEqual(1, composite1.Node.Count);
Assert.AreEqual(composite1.Node.NodeID, composite2.Node.Parent.NodeID);
composite2GameObject.SetActive(false);
yield return(null);
Assert.True(composite1GameObject);
Assert.True(composite1);
Assert.True(composite2GameObject);
Assert.True(composite2);
Assert.AreEqual(1, CSGManager.TreeBranchCount, "Expected 1 TreeBranch to Exist");
Assert.AreEqual(2, CSGManager.TreeNodeCount, "Expected 2 TreeNodes to Exist");
Assert.AreEqual(0, composite1.Node.Count);
}
public IEnumerator CreateComposite_UndoCreateGameObject_CompositeDoesNotExist()
{
var scene = TestUtility.defaultScene;
var composite = TestUtility.CreateUndoableGameObjectWithComposite();
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.PerformUndo();
yield return(null);
Assert.False(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));
}
