public void Tree_InsertChildBrushOfOtherTree_MovesBrushToTree()
{
const int brushUserID = 10;
const int treeUserID1 = 11;
const int treeUserID2 = 12;
var brush = CSGTreeBrush.Create(userID: brushUserID, dummyBrushMeshInstance);
var tree2 = CSGTree.Create(treeUserID2);
var tree1 = CSGTree.Create(treeUserID1, new CSGTreeNode[] { brush });
CompactHierarchyManager.ClearDirty(brush);
CompactHierarchyManager.ClearDirty(tree1);
CompactHierarchyManager.ClearDirty(tree2);
var result = tree2.Insert(0, brush);
Assert.IsTrue(result);
Assert.IsTrue(brush.Dirty);
Assert.IsTrue(tree1.Dirty);
Assert.IsTrue(tree2.Dirty);
Assert.IsFalse(TestUtility.IsInTree(tree1, brush));
Assert.IsTrue(TestUtility.IsInTree(tree2, brush));
Assert.AreEqual(0, TestUtility.CountOfBrushesInTree(tree1));
Assert.AreEqual(1, TestUtility.CountOfBrushesInTree(tree2));
Assert.AreEqual(0, tree1.Count);
Assert.AreEqual(1, tree2.Count);
Assert.AreEqual((CSGTreeNode)tree2, (CSGTreeNode)brush.Tree);
Assert.AreEqual((CSGTreeNode)tree2, (CSGTreeNode)brush.Parent);
TestUtility.ExpectValidBrushWithUserID(ref brush, brushUserID);
TestUtility.ExpectValidTreeWithUserID(ref tree1, treeUserID1);
TestUtility.ExpectValidTreeWithUserID(ref tree2, treeUserID2);
}
public void CreateTreeWithChildren()
{
const int brushUserID = 10;
const int branchUserID = 11;
const int treeUserID = 12;
CSGTreeBrush brush = CSGTreeBrush.Create(userID: brushUserID);
CSGTreeBranch branch = CSGTreeBranch.Create(branchUserID);
CSGManager.ClearDirty(brush);
CSGManager.ClearDirty(branch);
CSGTree tree = CSGTree.Create(treeUserID, new CSGTreeNode[] { brush, branch });
TestUtility.ExpectValidTreeWithUserID(ref tree, treeUserID);
Assert.AreEqual(true, branch.Dirty);
Assert.AreEqual(true, tree.Dirty);
Assert.AreEqual(true, brush.Dirty);
Assert.AreEqual(0, brush.Parent.NodeID);
Assert.AreEqual(tree.NodeID, brush.Tree.NodeID);
Assert.AreEqual(0, branch.Parent.NodeID);
Assert.AreEqual(tree.NodeID, branch.Tree.NodeID);
Assert.AreEqual(0, branch.Count);
Assert.AreEqual(2, tree.Count);
Assert.AreEqual(1, CSGManager.TreeBrushCount);
Assert.AreEqual(1, CSGManager.TreeBranchCount);
Assert.AreEqual(1, CSGManager.TreeCount);
Assert.AreEqual(3, CSGManager.TreeNodeCount);
}
public void CreateTreeWithChildren()
{
const int brushUserID = 10;
const int branchUserID = 11;
const int treeUserID = 12;
CSGTreeBrush brush = CSGTreeBrush.Create(userID: brushUserID);
CSGTreeBranch branch = CSGTreeBranch.Create(branchUserID);
CompactHierarchyManager.ClearDirty(brush);
CompactHierarchyManager.ClearDirty(branch);
CSGTree tree = CSGTree.Create(treeUserID, new CSGTreeNode[] { brush, branch });
TestUtility.ExpectValidTreeWithUserID(ref tree, treeUserID);
Assert.IsTrue(branch.Dirty);
Assert.IsTrue(tree.Dirty);
Assert.IsTrue(brush.Dirty);
Assert.AreEqual(0, branch.Count);
Assert.AreEqual(2, tree.Count);
Assert.AreEqual((CSGTreeNode)tree, (CSGTreeNode)brush.Parent);
Assert.AreEqual((CSGTreeNode)tree, (CSGTreeNode)brush.Tree);
Assert.AreEqual((CSGTreeNode)tree, (CSGTreeNode)branch.Parent);
Assert.AreEqual((CSGTreeNode)tree, (CSGTreeNode)branch.Tree);
}
public void Tree_AddSameBranchTwice_ReturnsFalse()
{
const int branchUserID = 10;
const int treeUserID = 11;
var branch = CSGTreeBranch.Create(branchUserID);
var tree = CSGTree.Create(treeUserID);
CSGManager.ClearDirty(branch);
CSGManager.ClearDirty(tree);
var result1 = tree.Add(branch);
var result2 = tree.Add(branch);
Assert.AreEqual(true, result1);
Assert.AreEqual(false, result2);
TestUtility.ExpectValidBranchWithUserID(ref branch, branchUserID);
TestUtility.ExpectValidTreeWithUserID(ref tree, treeUserID);
Assert.AreEqual(true, branch.Dirty);
Assert.AreEqual(true, tree.Dirty);
Assert.AreEqual(0, tree.CountOfBrushesInTree);
Assert.AreEqual(0, branch.Parent.NodeID);
Assert.AreEqual(tree.NodeID, branch.Tree.NodeID);
Assert.AreEqual(0, branch.Count);
Assert.AreEqual(1, tree.Count);
Assert.AreEqual(0, CSGManager.TreeBrushCount);
Assert.AreEqual(1, CSGManager.TreeCount);
Assert.AreEqual(1, CSGManager.TreeBranchCount);
Assert.AreEqual(2, CSGManager.TreeNodeCount);
}
public void Tree_AddBranchAddBrushReversed_ContainsBranchThatContainsBrush()
{
const int brushUserID = 10;
const int branchUserID = 11;
const int treeUserID = 12;
var brush = CSGTreeBrush.Create(userID: brushUserID);
var branch = CSGTreeBranch.Create(branchUserID);
var tree = CSGTree.Create(treeUserID);
CompactHierarchyManager.ClearDirty(brush);
CompactHierarchyManager.ClearDirty(branch);
CompactHierarchyManager.ClearDirty(tree);
var result1 = tree.Add(branch);
var result2 = branch.Add(brush);
Assert.IsTrue(result1);
Assert.IsTrue(result2);
TestUtility.ExpectValidBrushWithUserID(ref brush, brushUserID);
TestUtility.ExpectValidBranchWithUserID(ref branch, branchUserID);
TestUtility.ExpectValidTreeWithUserID(ref tree, treeUserID);
Assert.IsTrue(branch.Dirty);
Assert.IsTrue(tree.Dirty);
Assert.IsTrue(brush.Dirty);
Assert.IsTrue(TestUtility.IsInTree(tree, brush));
Assert.AreEqual(1, branch.Count);
Assert.AreEqual(1, tree.Count);
Assert.AreEqual((CSGTreeNode)branch, (CSGTreeNode)brush.Parent);
Assert.AreEqual((CSGTreeNode)tree, (CSGTreeNode)brush.Tree);
Assert.AreEqual((CSGTreeNode)tree, (CSGTreeNode)branch.Parent);
Assert.AreEqual((CSGTreeNode)tree, (CSGTreeNode)branch.Tree);
}
public void Tree_AddChildBrushOfOtherTree_MovesBrushToTree()
{
const int brushUserID = 10;
const int treeUserID1 = 11;
const int treeUserID2 = 12;
var brush = CSGTreeBrush.Create(userID: brushUserID);
var tree2 = CSGTree.Create(treeUserID2);
var tree1 = CSGTree.Create(treeUserID1, new CSGTreeNode[] { brush });
CSGManager.ClearDirty(brush);
CSGManager.ClearDirty(tree1);
CSGManager.ClearDirty(tree2);
var result = tree2.Add(brush);
Assert.AreEqual(true, result);
TestUtility.ExpectValidBrushWithUserID(ref brush, brushUserID);
TestUtility.ExpectValidTreeWithUserID(ref tree1, treeUserID1);
TestUtility.ExpectValidTreeWithUserID(ref tree2, treeUserID2);
Assert.AreEqual(true, tree1.Dirty);
Assert.AreEqual(true, tree2.Dirty);
Assert.AreEqual(true, brush.Dirty);
Assert.AreEqual(false, tree1.IsInTree(brush));
Assert.AreEqual(true, tree2.IsInTree(brush));
Assert.AreEqual(0, tree1.CountOfBrushesInTree);
Assert.AreEqual(1, tree2.CountOfBrushesInTree);
Assert.AreEqual(tree2.NodeID, brush.Tree.NodeID);
Assert.AreEqual(0, brush.Parent.NodeID);
Assert.AreEqual(0, tree1.Count);
Assert.AreEqual(1, tree2.Count);
Assert.AreEqual(2, CSGManager.TreeCount);
Assert.AreEqual(1, CSGManager.TreeBrushCount);
Assert.AreEqual(0, CSGManager.TreeBranchCount);
Assert.AreEqual(3, CSGManager.TreeNodeCount);
}
public void TreeWith3Children_RemoveRangeWithCount0AndInvalidIndex_ReturnsTrue()
{
const int brushUserID1 = 10;
const int brushUserID2 = 11;
const int brushUserID3 = 12;
const int treeUserID = 13;
var brush1 = CSGTreeBrush.Create(userID: brushUserID1);
var brush2 = CSGTreeBrush.Create(userID: brushUserID2);
var brush3 = CSGTreeBrush.Create(userID: brushUserID3);
var tree = CSGTree.Create(treeUserID, new CSGTreeNode[] { brush1, brush2, brush3 });
CompactHierarchyManager.ClearDirty(brush1);
CompactHierarchyManager.ClearDirty(brush2);
CompactHierarchyManager.ClearDirty(brush3);
CompactHierarchyManager.ClearDirty(tree);
var result = tree.RemoveRange(3, 0);
Assert.IsTrue(result);
TestUtility.ExpectValidBrushWithUserID(ref brush1, brushUserID1);
TestUtility.ExpectValidBrushWithUserID(ref brush2, brushUserID2);
TestUtility.ExpectValidBrushWithUserID(ref brush3, brushUserID3);
TestUtility.ExpectValidTreeWithUserID(ref tree, treeUserID);
Assert.AreEqual(3, tree.Count);
Assert.AreEqual((CSGTreeNode)tree, (CSGTreeNode)brush1.Parent);
Assert.AreEqual((CSGTreeNode)tree, (CSGTreeNode)brush1.Tree);
Assert.AreEqual((CSGTreeNode)tree, (CSGTreeNode)brush2.Parent);
Assert.AreEqual((CSGTreeNode)tree, (CSGTreeNode)brush2.Tree);
Assert.AreEqual((CSGTreeNode)tree, (CSGTreeNode)brush3.Parent);
Assert.AreEqual((CSGTreeNode)tree, (CSGTreeNode)brush3.Tree);
}
public void CreateTree_WithoutUserID()
{
CSGTree tree = CSGTree.Create();
TestUtility.ExpectValidTreeWithUserID(ref tree, 0);
Assert.IsTrue(tree.Dirty);
}
public void TreeWith3Children_RemoveRangeAt0WithCount3_TreeIsEmpty()
{
const int brushUserID1 = 10;
const int brushUserID2 = 11;
const int brushUserID3 = 12;
const int treeUserID = 13;
var brush1 = CSGTreeBrush.Create(userID: brushUserID1);
var brush2 = CSGTreeBrush.Create(userID: brushUserID2);
var brush3 = CSGTreeBrush.Create(userID: brushUserID3);
var tree = CSGTree.Create(treeUserID, new CSGTreeNode[] { brush1, brush2, brush3 });
CompactHierarchyManager.ClearDirty(brush1);
CompactHierarchyManager.ClearDirty(brush2);
CompactHierarchyManager.ClearDirty(brush3);
CompactHierarchyManager.ClearDirty(tree);
var result = tree.RemoveRange(0, 3);
Assert.IsTrue(result);
TestUtility.ExpectValidBrushWithUserID(ref brush1, brushUserID1);
TestUtility.ExpectValidBrushWithUserID(ref brush2, brushUserID2);
TestUtility.ExpectValidBrushWithUserID(ref brush3, brushUserID3);
TestUtility.ExpectValidTreeWithUserID(ref tree, treeUserID);
Assert.IsTrue(brush1.Dirty);
Assert.IsTrue(brush2.Dirty);
Assert.IsTrue(brush3.Dirty);
Assert.IsTrue(tree.Dirty);
Assert.IsFalse(brush1.Parent.Valid);
Assert.IsFalse(brush1.Tree.Valid);
Assert.IsFalse(brush2.Parent.Valid);
Assert.IsFalse(brush2.Tree.Valid);
Assert.IsFalse(brush3.Parent.Valid);
Assert.IsFalse(brush3.Tree.Valid);
Assert.AreEqual(0, tree.Count);
}
public void TreeWith3Children_RemoveRangeAt1WithTooLargeCount_ReturnsFalse()
{
const int brushUserID1 = 10;
const int brushUserID2 = 11;
const int brushUserID3 = 12;
const int treeUserID = 13;
var brush1 = CSGTreeBrush.Create(userID: brushUserID1);
var brush2 = CSGTreeBrush.Create(userID: brushUserID2);
var brush3 = CSGTreeBrush.Create(userID: brushUserID3);
var tree = CSGTree.Create(treeUserID, new CSGTreeNode[] { brush1, brush2, brush3 });
CompactHierarchyManager.ClearDirty(brush1);
CompactHierarchyManager.ClearDirty(brush2);
CompactHierarchyManager.ClearDirty(brush3);
CompactHierarchyManager.ClearDirty(tree);
var result = tree.RemoveRange(1, 3);
LogAssert.Expect(LogType.Error, new Regex("must be below or equal to"));
Assert.IsFalse(result);
TestUtility.ExpectValidBrushWithUserID(ref brush1, brushUserID1);
TestUtility.ExpectValidBrushWithUserID(ref brush2, brushUserID2);
TestUtility.ExpectValidBrushWithUserID(ref brush3, brushUserID3);
TestUtility.ExpectValidTreeWithUserID(ref tree, treeUserID);
Assert.AreEqual(3, tree.Count);
Assert.AreEqual((CSGTreeNode)tree, (CSGTreeNode)brush1.Parent);
Assert.AreEqual((CSGTreeNode)tree, (CSGTreeNode)brush1.Tree);
Assert.AreEqual((CSGTreeNode)tree, (CSGTreeNode)brush2.Parent);
Assert.AreEqual((CSGTreeNode)tree, (CSGTreeNode)brush2.Tree);
Assert.AreEqual((CSGTreeNode)tree, (CSGTreeNode)brush3.Parent);
Assert.AreEqual((CSGTreeNode)tree, (CSGTreeNode)brush3.Tree);
}
public void Tree_RemoveUnknownBrush_ReturnsFalse()
{
const int brushUserID = 10;
const int treeUserID = 11;
var brush = CSGTreeBrush.Create(userID: brushUserID);
var tree = CSGTree.Create(treeUserID);
CSGManager.ClearDirty(brush);
CSGManager.ClearDirty(tree);
var result = tree.Remove(brush);
Assert.AreEqual(false, result);
TestUtility.ExpectValidBrushWithUserID(ref brush, brushUserID);
Assert.AreEqual(false, tree.IsInTree(brush));
Assert.AreEqual(0, tree.CountOfBrushesInTree);
Assert.AreEqual(false, tree.Dirty);
Assert.AreEqual(false, brush.Dirty);
Assert.AreEqual(0, brush.Parent.NodeID);
Assert.AreEqual(0, brush.Tree.NodeID);
Assert.AreEqual(0, tree.Count);
Assert.AreEqual(0, CSGManager.TreeBranchCount);
Assert.AreEqual(1, CSGManager.TreeBrushCount);
Assert.AreEqual(1, CSGManager.TreeCount);
Assert.AreEqual(2, CSGManager.TreeNodeCount);
}
public void TreeWithChildBranch_RemoveBranch_IsEmpty()
{
const int branchUserID = 10;
const int treeUserID = 11;
var branch = CSGTreeBranch.Create(branchUserID);
var tree = CSGTree.Create(treeUserID, new CSGTreeNode[] { branch });
CSGManager.ClearDirty(branch);
CSGManager.ClearDirty(tree);
var result = tree.Remove(branch);
Assert.AreEqual(true, result);
TestUtility.ExpectValidBranchWithUserID(ref branch, branchUserID);
Assert.AreEqual(true, tree.Dirty);
Assert.AreEqual(true, branch.Dirty);
Assert.AreEqual(0, branch.Parent.NodeID);
Assert.AreEqual(0, branch.Tree.NodeID);
Assert.AreEqual(0, branch.Count);
Assert.AreEqual(0, tree.Count);
Assert.AreEqual(0, CSGManager.TreeBrushCount);
Assert.AreEqual(1, CSGManager.TreeBranchCount);
Assert.AreEqual(1, CSGManager.TreeCount);
Assert.AreEqual(2, CSGManager.TreeNodeCount);
}
public void TreeWith3Children_RemoveRangeWithCount0AndInvalidIndex_ReturnsFalse()
{
const int brushUserID1 = 10;
const int brushUserID2 = 11;
const int brushUserID3 = 12;
const int treeUserID = 13;
var brush1 = CSGTreeBrush.Create(userID: brushUserID1);
var brush2 = CSGTreeBrush.Create(userID: brushUserID2);
var brush3 = CSGTreeBrush.Create(userID: brushUserID3);
var tree = CSGTree.Create(treeUserID, new CSGTreeNode[] { brush1, brush2, brush3 });
CSGManager.ClearDirty(brush1);
CSGManager.ClearDirty(brush2);
CSGManager.ClearDirty(brush3);
CSGManager.ClearDirty(tree);
var result = tree.RemoveRange(3, 0);
Assert.AreEqual(false, result);
TestUtility.ExpectValidBrushWithUserID(ref brush1, brushUserID1);
TestUtility.ExpectValidBrushWithUserID(ref brush2, brushUserID2);
TestUtility.ExpectValidBrushWithUserID(ref brush3, brushUserID3);
TestUtility.ExpectValidTreeWithUserID(ref tree, treeUserID);
Assert.AreEqual(0, brush1.Parent.NodeID);
Assert.AreEqual(tree.NodeID, brush1.Tree.NodeID);
Assert.AreEqual(0, brush2.Parent.NodeID);
Assert.AreEqual(tree.NodeID, brush2.Tree.NodeID);
Assert.AreEqual(0, brush3.Parent.NodeID);
Assert.AreEqual(tree.NodeID, brush3.Tree.NodeID);
Assert.AreEqual(3, tree.Count);
Assert.AreEqual(0, CSGManager.TreeBranchCount);
Assert.AreEqual(3, CSGManager.TreeBrushCount);
Assert.AreEqual(1, CSGManager.TreeCount);
Assert.AreEqual(4, CSGManager.TreeNodeCount);
}
public void TreeWithChildBrush_RemoveSameBrushTwice_ReturnsFalse()
{
const int brushUserID = 10;
const int treeUserID = 11;
var brush = CSGTreeBrush.Create(userID: brushUserID);
var tree = CSGTree.Create(treeUserID, new CSGTreeNode[] { brush });
CSGManager.ClearDirty(brush);
CSGManager.ClearDirty(tree);
var result1 = tree.Remove(brush);
var result2 = tree.Remove(brush);
Assert.AreEqual(true, result1);
Assert.AreEqual(false, result2);
TestUtility.ExpectValidBrushWithUserID(ref brush, brushUserID);
Assert.AreEqual(true, brush.Dirty);
Assert.AreEqual(true, tree.Dirty);
Assert.AreEqual(false, tree.IsInTree(brush));
Assert.AreEqual(0, tree.CountOfBrushesInTree);
Assert.AreEqual(0, brush.Parent.NodeID);
Assert.AreEqual(0, brush.Tree.NodeID);
Assert.AreEqual(0, tree.Count);
Assert.AreEqual(0, CSGManager.TreeBranchCount, "Expected 0 TreeBranches to Exist");
Assert.AreEqual(1, CSGManager.TreeBrushCount, "Expected 1 TreeBrush to Exist");
Assert.AreEqual(1, CSGManager.TreeCount, "Expected 1 Tree to Exist");
Assert.AreEqual(2, CSGManager.TreeNodeCount, "Expected 2 TreeNodes to Exist");
}
public void Tree_SetChildrenWithBranchWithBrushReversed_ContainsBranchThatContainsBrush()
{
const int brushUserID = 10;
const int branchUserID = 11;
const int treeUserID = 12;
var brush = CSGTreeBrush.Create(userID: brushUserID);
var branch = CSGTreeBranch.Create(branchUserID);
var tree = CSGTree.Create(treeUserID);
CompactHierarchyManager.ClearDirty(brush);
CompactHierarchyManager.ClearDirty(branch);
CompactHierarchyManager.ClearDirty(tree);
tree.InsertRange(0, new CSGTreeNode[] { branch });
branch.InsertRange(0, new CSGTreeNode[] { brush });
TestUtility.ExpectValidBrushWithUserID(ref brush, brushUserID);
TestUtility.ExpectValidBranchWithUserID(ref branch, branchUserID);
TestUtility.ExpectValidTreeWithUserID(ref tree, treeUserID);
Assert.IsTrue(brush.Dirty);
Assert.IsTrue(branch.Dirty);
Assert.IsTrue(tree.Dirty);
Assert.IsTrue(TestUtility.IsInTree(tree, brush));
Assert.AreEqual(1, TestUtility.CountOfBrushesInTree(tree));
Assert.AreEqual(1, branch.Count);
Assert.AreEqual(1, tree.Count);
Assert.AreEqual((CSGTreeNode)branch, (CSGTreeNode)brush.Parent);
Assert.AreEqual((CSGTreeNode)tree, (CSGTreeNode)brush.Tree);
Assert.AreEqual((CSGTreeNode)tree, (CSGTreeNode)branch.Parent);
Assert.AreEqual((CSGTreeNode)tree, (CSGTreeNode)branch.Tree);
}
public void Tree_AddBrush_ContainsBrush()
{
const int brushUserID = 10;
const int treeUserID = 11;
var brush = CSGTreeBrush.Create(userID: brushUserID);
var tree = CSGTree.Create(treeUserID);
CSGManager.ClearDirty(brush);
CSGManager.ClearDirty(tree);
var result = tree.Add(brush);
Assert.AreEqual(true, result);
TestUtility.ExpectValidBrushWithUserID(ref brush, brushUserID);
TestUtility.ExpectValidTreeWithUserID(ref tree, treeUserID);
Assert.AreEqual(true, tree.Dirty);
Assert.AreEqual(true, brush.Dirty);
Assert.AreEqual(true, tree.IsInTree(brush));
Assert.AreEqual(1, tree.CountOfBrushesInTree);
Assert.AreEqual(0, brush.Parent.NodeID);
Assert.AreEqual(tree.NodeID, brush.Tree.NodeID);
Assert.AreEqual(1, tree.Count);
Assert.AreEqual(0, CSGManager.TreeBranchCount);
Assert.AreEqual(1, CSGManager.TreeBrushCount);
Assert.AreEqual(1, CSGManager.TreeCount);
Assert.AreEqual(2, CSGManager.TreeNodeCount);
}
public void TreeWithBranch_DestroyBranch_TreeIsEmpty()
{
const int branchUserID = 10;
const int treeUserID = 11;
var branch = CSGTreeBranch.Create(branchUserID);
var tree = CSGTree.Create(treeUserID);
tree.InsertRange(0, new CSGTreeNode[] { branch });
CSGManager.ClearDirty(branch);
CSGManager.ClearDirty(tree);
var result = branch.Destroy();
Assert.AreEqual(true, result);
TestUtility.ExpectInvalidBranch(ref branch);
Assert.AreEqual(true, tree.Dirty);
Assert.AreEqual(0, branch.Parent.NodeID);
Assert.AreEqual(0, branch.Tree.NodeID);
Assert.AreEqual(0, branch.Count);
Assert.AreEqual(0, tree.Count);
Assert.AreEqual(0, CSGManager.TreeBrushCount);
Assert.AreEqual(0, CSGManager.TreeBranchCount);
Assert.AreEqual(1, CSGManager.TreeCount);
Assert.AreEqual(1, CSGManager.TreeNodeCount);
}
public void Tree_SetChildrenWithBranchWithBrushReversed_ContainsBranchThatContainsBrush()
{
const int brushUserID = 10;
const int branchUserID = 11;
const int treeUserID = 12;
var brush = CSGTreeBrush.Create(userID: brushUserID);
var branch = CSGTreeBranch.Create(branchUserID);
var tree = CSGTree.Create(treeUserID);
CSGManager.ClearDirty(brush);
CSGManager.ClearDirty(branch);
CSGManager.ClearDirty(tree);
tree.InsertRange(0, new CSGTreeNode[] { branch });
branch.InsertRange(0, new CSGTreeNode[] { brush });
TestUtility.ExpectValidBrushWithUserID(ref brush, brushUserID);
TestUtility.ExpectValidBranchWithUserID(ref branch, branchUserID);
TestUtility.ExpectValidTreeWithUserID(ref tree, treeUserID);
Assert.AreEqual(true, brush.Dirty);
Assert.AreEqual(true, branch.Dirty);
Assert.AreEqual(true, tree.Dirty);
Assert.AreEqual(true, tree.IsInTree(brush));
Assert.AreEqual(1, tree.CountOfBrushesInTree);
Assert.AreEqual(branch.NodeID, brush.Parent.NodeID);
Assert.AreEqual(tree.NodeID, brush.Tree.NodeID);
Assert.AreEqual(0, branch.Parent.NodeID);
Assert.AreEqual(tree.NodeID, branch.Tree.NodeID);
Assert.AreEqual(1, branch.Count);
Assert.AreEqual(1, tree.Count);
Assert.AreEqual(1, CSGManager.TreeBranchCount, "Expected 1 TreeBranch to Exist");
Assert.AreEqual(1, CSGManager.TreeBrushCount, "Expected 1 TreeBrush to Exist");
Assert.AreEqual(1, CSGManager.TreeCount, "Expected 1 Tree to Exist");
Assert.AreEqual(3, CSGManager.TreeNodeCount, "Expected 3 TreeNodes to Exist");
}
public void Tree_SetChildrenWithBranch_ContainsBranch()
{
const int branchUserID = 10;
const int treeUserID = 11;
var branch = CSGTreeBranch.Create(branchUserID);
var tree = CSGTree.Create(treeUserID);
CSGManager.ClearDirty(branch);
CSGManager.ClearDirty(tree);
tree.InsertRange(0, new CSGTreeNode[] { branch });
TestUtility.ExpectValidBranchWithUserID(ref branch, branchUserID);
TestUtility.ExpectValidTreeWithUserID(ref tree, treeUserID);
Assert.AreEqual(true, branch.Dirty);
Assert.AreEqual(true, tree.Dirty);
Assert.AreEqual(0, branch.Parent.NodeID);
Assert.AreEqual(tree.NodeID, branch.Tree.NodeID);
Assert.AreEqual(0, branch.Count);
Assert.AreEqual(1, tree.Count);
Assert.AreEqual(0, CSGManager.TreeBrushCount, "Expected 0 TreeBrushes to Exist");
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");
}
public static void ExpectInvalidTree(ref CSGTree tree)
{
CSGNodeType type = ((CSGTreeNode)tree).Type;
Assert.IsFalse(tree.Valid);
Assert.AreEqual(0, tree.UserID);
Assert.AreEqual(CSGNodeType.None, type);
}
public static void ExpectValidTreeWithUserID(ref CSGTree tree, int userID)
{
CSGNodeType type = ((CSGTreeNode)tree).Type;
Assert.IsTrue(tree.Valid);
Assert.AreEqual(userID, tree.UserID);
Assert.AreEqual(CSGNodeType.Tree, type);
}
public CSGTree ToCSGTree(out HashSet <CSGNode> animatedNodes)
{
animatedNodes = new HashSet <CSGNode>();
var tree = new CSGTree();
tree.RootNode = RootNode.ToCSGNode(null, animatedNodes, false);
return(tree);
}
public static void ExpectInvalidTree(ref CSGTree model)
{
CSGNodeType type = CSGTreeNode.Encapsulate(model.NodeID).Type;
Assert.AreEqual(false, model.Valid);
Assert.AreEqual(0, model.UserID);
Assert.AreEqual(CSGNodeType.None, type);
}
public void CreateTree_WithoutUserID()
{
CSGTree tree = CSGTree.Create();
TestUtility.ExpectValidTreeWithUserID(ref tree, 0);
Assert.AreEqual(true, tree.Dirty);
Assert.AreEqual(1, CSGManager.TreeNodeCount);
Assert.AreEqual(1, CSGManager.TreeCount);
}
public static void ExpectValidTreeWithUserID(ref CSGTree model, int userID)
{
CSGNodeType type = CSGTreeNode.Encapsulate(model.NodeID).Type;
Assert.AreEqual(true, model.Valid);
Assert.AreNotEqual(0, model.NodeID);
Assert.AreEqual(userID, model.UserID);
Assert.AreEqual(CSGNodeType.Tree, type);
}
public void CreateTree_WithUserID()
{
const int treeUserID = 10;
CSGTree tree = CSGTree.Create(treeUserID);
TestUtility.ExpectValidTreeWithUserID(ref tree, treeUserID);
Assert.IsTrue(tree.Dirty);
}
public void CreateTreeWithNullChildren()
{
const int treeUserID = 12;
CSGTree tree = CSGTree.Create(treeUserID, null);
TestUtility.ExpectValidTreeWithUserID(ref tree, treeUserID);
Assert.AreEqual(0, tree.Count);
}
public void Mesh_CreateSubtractiveCubeBrush_RetrieveMesh_RetrievedMeshIsEmpty()
{
var tree = CSGTree.Create(
CreateCubeBrush(operation: CSGOperationType.Subtractive)
);
GeneratedMeshContents generatedMesh = GeneratedMeshAndValidate(tree, simpleMeshTypes, expectEmpty: true);
Assert.Null(generatedMesh);
}
public void Mesh_CreateAdditiveBoxBrush_RetrieveMesh_RetrievedMeshIsACube()
{
var tree = CSGTree.Create(
CreateBoxBrush(operation: CSGOperationType.Additive)
);
GeneratedMeshContents generatedMesh = GeneratedMeshAndValidate(tree, simpleMeshTypes, expectEmpty: false);
ValidateIsCorrectBox(generatedMesh);
}
public void Mesh_CreateIntersectionBoxBrush_RetrieveMesh_RetrievedMeshIsEmpty()
{
var tree = CSGTree.Create(
CreateBoxBrush(operation: CSGOperationType.Intersecting)
);
GeneratedMeshContents generatedMesh = GeneratedMeshAndValidate(tree, simpleMeshTypes, expectEmpty: true);
Assert.Null(generatedMesh);
}
