public CSGNode(CSGNodeType branchOperator) { this.NodeType = branchOperator; this.Left = null; this.Right = null; this.Translation = new Vector3(0, 0, 0); this.LocalTranslation = new Vector3(0, 0, 0); }
public static void UpdateChildTransformations(CSGNode node) { if (node.NodeType == CSGNodeType.Brush) return; UpdateChildTransformations(node.Left, node.Translation); UpdateChildTransformations(node.Right, node.Translation); }
public static void UpdateChildTransformations(CSGNode node, Vector3 parentTranslation) { node.Translation = Vector3.Add(parentTranslation, node.LocalTranslation); if (node.NodeType == CSGNodeType.Brush) return; UpdateChildTransformations(node.Left, node.Translation); UpdateChildTransformations(node.Right, node.Translation); }
public static void UpdateChildTransformations(CSGNode node) { if (node.NodeType == CSGNodeType.Brush) { return; } UpdateChildTransformations(node.Left, node.Translation); UpdateChildTransformations(node.Right, node.Translation); }
public static void UpdateChildTransformations(CSGNode node, Vector3 parentTranslation) { node.Translation = Vector3.Add(parentTranslation, node.LocalTranslation); if (node.NodeType == CSGNodeType.Brush) { return; } UpdateChildTransformations(node.Left, node.Translation); UpdateChildTransformations(node.Right, node.Translation); }
public CSGNode(CSGNodeType branchOperator, CSGNode left, CSGNode right) { this.NodeType = branchOperator; this.Left = left; this.Right = right; this.Translation = new Vector3(0, 0, 0); this.LocalTranslation = new Vector3(0, 0, 0); left.Parent = this; right.Parent = this; }
public CSGNode(CSGNodeType branchOperator, CSGNode left, CSGNode right) { this.NodeType = branchOperator; this.Left = left; this.Right = right; this.Translation = new Vector3(0, 0, 0); this.LocalTranslation = new Vector3(0, 0, 0); left.Parent = this; right.Parent = this; }
public static IEnumerable<CSGNode> FindChildNodes(CSGNode node) { yield return node; if (node.NodeType != CSGNodeType.Brush) { foreach (var child in FindChildNodes(node.Left)) yield return child; foreach (var child in FindChildNodes(node.Right)) yield return child; } }
public static IEnumerable<CSGNode> FindChildBrushes(CSGNode node) { if (node.NodeType != CSGNodeType.Brush) { foreach (var brush in FindChildBrushes(node.Left)) yield return brush; foreach (var brush in FindChildBrushes(node.Right)) yield return brush; yield break; } else yield return node; }
private static void UpdateMesh(CSGNode node, CSGNode root) { //if (node.Left != null) UpdateMesh(node.Left, node); //if (node.Right != null) UpdateMesh(node.Right, node); var processedNode = node; var processedMesh = node.cachedMesh; var inputPolygons = processedMesh.Polygons; var insidePolygons = new List <Polygon>(inputPolygons.Count); var outsidePolygons = new List <Polygon>(inputPolygons.Count); var alignedPolygons = new List <Polygon>(inputPolygons.Count); var reversedPolygons = new List <Polygon>(inputPolygons.Count); CSGCategorization.Categorize(processedNode, processedMesh, root, inputPolygons, // these are the polygons that are categorized insidePolygons, alignedPolygons, reversedPolygons, outsidePolygons ); // Flag all non aligned polygons as being invisible, and store their categorizations // so we can use it if we instance this mesh. foreach (var polygon in insidePolygons) { polygon.Category = PolygonCategory.Inside; polygon.Visible = false; } foreach (var polygon in outsidePolygons) { polygon.Category = PolygonCategory.Outside; polygon.Visible = false; } foreach (var polygon in alignedPolygons) { polygon.Category = PolygonCategory.Aligned; } foreach (var polygon in reversedPolygons) { polygon.Category = PolygonCategory.ReverseAligned; } }
public static void UpdateBounds(CSGNode node) { if (node.NodeType != CSGNodeType.Brush) { var leftNode = node.Left; var rightNode = node.Right; UpdateBounds(leftNode); UpdateBounds(rightNode); node.Bounds.Clear(); node.Bounds.Add(leftNode.Bounds.Translated(Vector3.Subtract(leftNode.Translation, node.Translation))); node.Bounds.Add(rightNode.Bounds.Translated(Vector3.Subtract(rightNode.Translation, node.Translation))); } }
public static void UpdateBounds(CSGNode node) { if (node.NodeType != CSGNodeType.Brush) { var leftNode = node.Left; var rightNode = node.Right; UpdateBounds(leftNode); UpdateBounds(rightNode); node.Bounds.Clear(); node.Bounds.Add(leftNode.Bounds.Translated(Vector3.Subtract(leftNode.Translation, node.Translation))); node.Bounds.Add(rightNode.Bounds.Translated(Vector3.Subtract(rightNode.Translation, node.Translation))); } }
public static IEnumerable<CSGNode> FindChildBrushes(CSGNode node, Microsoft.Xna.Framework.Matrix transformation) { node.WorldTransformation = node.Transformation.Transform * transformation; if (node.NodeType != CSGNodeType.Brush) { foreach (var brush in FindChildBrushes(node.Left, node.WorldTransformation)) yield return brush; foreach (var brush in FindChildBrushes(node.Right, node.WorldTransformation)) yield return brush; yield break; } else yield return node; }
public static IEnumerable <CSGNode> FindChildNodes(CSGNode node) { yield return(node); if (node.NodeType != CSGNodeType.Brush) { foreach (var child in FindChildNodes(node.Left)) { yield return(child); } foreach (var child in FindChildNodes(node.Right)) { yield return(child); } } }
public static IEnumerable <CSGNode> FindChildBrushes(CSGNode node) { if (node.NodeType != CSGNodeType.Brush) { foreach (var brush in FindChildBrushes(node.Left)) { yield return(brush); } foreach (var brush in FindChildBrushes(node.Right)) { yield return(brush); } yield break; } else { yield return(node); } }
//public static IEnumerable<CSGNode> FindChildNodes(CSGNode node) //{ // yield return node; // if (node.NodeType != CSGNodeType.Brush) // { // foreach (var child in FindChildNodes(node.Left)) // yield return child; // foreach (var child in FindChildNodes(node.Right)) // yield return child; // } //} #endregion #region FindChildBrushes public static IEnumerable <CSGNode> FindChildBrushes(CSGNode node, Microsoft.Xna.Framework.Matrix transformation) { node.WorldTransformation = node.Transformation.Transform * transformation; if (node.NodeType != CSGNodeType.Brush) { foreach (var brush in FindChildBrushes(node.Left, node.WorldTransformation)) { yield return(brush); } foreach (var brush in FindChildBrushes(node.Right, node.WorldTransformation)) { yield return(brush); } yield break; } else { yield return(node); } }
// Create meshes for a given number of nodes and perform CSG on these. #region ProcessCSGNodes private static void ProcessNode(CSGNode node, CSGNode root) { if (node.cachedMesh == null) { if (node.NodeType != CSGNodeType.Brush) { ProcessNode(node.Left, node); ProcessNode(node.Right, node); node.cachedMesh = CSGMesh.Combine(node.Translation, node.Left, node.Right); node.Bounds.Clear(); node.Bounds.Add(node.Left.Bounds.Translated(Vector3.Subtract(node.Left.Translation, node.Translation))); node.Bounds.Add(node.Right.Bounds.Translated(Vector3.Subtract(node.Right.Translation, node.Translation))); UpdateMesh(node, root); } else { node.cachedMesh = CSGMesh.CreateFromPlanes(node.Generator.GetPlanes(node.WorldTransformation)); node.Bounds.Set(node.cachedMesh.Bounds); } } }
static void FindParentNode(Transform opTransform, out CSGNode parentNode, out Transform parentTransform) { var iterator = opTransform.parent; while (iterator) { var currentNodeObj = iterator.GetComponent(TypeConstants.CSGNodeType); if (currentNodeObj) { var operationNode = currentNodeObj as CSGOperation; if (!operationNode || !operationNode.PassThrough) { parentNode = currentNodeObj as CSGNode; parentTransform = iterator; return; } } iterator = iterator.parent; } parentTransform = null; parentNode = null; }
public void Init(CSGNode node, Int32 nodeID) { Transform = node.transform; TransformID = node.transform.GetInstanceID(); NodeID = nodeID; }
public CSGNode(string id, CSGNodeType branchOperator, CSGNode left, CSGNode right) { this.NodeType = branchOperator; this.Left = left; this.Right = right; }
void CreateVisualObjects() { CleanUp(); //Debug.Log("CreateVisualObjects"); //prevForceGrid = Grid.ForceGrid; prevForcedGridCenter = Grid.ForcedGridCenter; prevForcedGridRotation = Grid.ForcedGridRotation; sourceSurfaceAlignment = PrefabSourceAlignment.AlignedFront; destinationSurfaceAlignment = PrefabDestinationAlignment.AlignToSurface; visualDragGameObject = new List <GameObject>(); foreach (var obj in dragGameObjects) { CSGNode node = obj.GetComponent <CSGNode>(); if (!node) { continue; } sourceSurfaceAlignment = node.PrefabSourceAlignment; destinationSurfaceAlignment = node.PrefabDestinationAlignment; GameObject copy; if (node && node.PrefabBehaviour == PrefabInstantiateBehaviour.Copy) { copy = GameObject.Instantiate <GameObject>(obj); } else { copy = PrefabUtility.InstantiatePrefab(obj) as GameObject; } if (!copy) { continue; } copy.name = obj.name; visualDragGameObject.Add(copy); } var model = SelectionUtility.LastUsedModel; if (model) { var parent = model.transform; int counter = 0; foreach (var obj in visualDragGameObject) { if (!obj) { continue; } if (obj.activeSelf) { obj.transform.SetParent(parent, false); obj.transform.SetSiblingIndex(hoverSiblingIndex + counter); counter++; } } } }
public static void Init(this HierarchyItem self, CSGNode node, Int32 nodeID) { self.Transform = node.transform; self.TransformID = node.transform.GetInstanceID(); self.NodeID = nodeID; }
// Categorize the given inputPolygons as being inside/outside or (reverse-)aligned // with the shape that is defined by the current brush or csg-branch. // When an inputPolygon crosses the node, it is split into pieces and every individual // piece is then categorized. #region Categorize public static void Categorize(CSGNode processedNode, CSGMesh processedMesh, CSGNode categorizationNode, List <Polygon> inputPolygons, List <Polygon> inside, List <Polygon> aligned, List <Polygon> revAligned, List <Polygon> outside) { // When you go deep enough in the tree it's possible that all categories point to the same // destination. So we detect that and potentially avoid a lot of wasted work. if (inside == revAligned && inside == aligned && inside == outside) { inside.AddRange(inputPolygons); return; } Restart: if (processedNode == categorizationNode) { // When the currently processed node is the same node as we categorize against, then // we know that all our polygons are visible and we set their default category // (usually aligned, unless it's an instancing node in which case it's precalculated) foreach (var polygon in inputPolygons) { switch (polygon.Category) { case PolygonCategory.Aligned: aligned.Add(polygon); break; case PolygonCategory.ReverseAligned: revAligned.Add(polygon); break; case PolygonCategory.Inside: inside.Add(polygon); break; case PolygonCategory.Outside: outside.Add(polygon); break; } // When brushes overlap and they share the same surface area we only want to keep // the polygons of the last brush in the tree, and skip all others. // At this point in the tree we know that this polygon belongs to this brush, so // we set it to visible. If the polygon is found to share the surface area with another // brush further on in the tree it'll be set to invisible again in mesh.Intersect. polygon.Visible = true; } return; } var leftNode = categorizationNode.Left; var rightNode = categorizationNode.Right; switch (categorizationNode.NodeType) { case CSGNodeType.Brush: { processedMesh.Intersect(categorizationNode.Bounds, categorizationNode.Generator.GetPlanes(categorizationNode.WorldTransformation), categorizationNode.Translation, processedNode.Translation, inputPolygons, inside, aligned, revAligned, outside); break; } case CSGNodeType.Addition: { // ( A || B) var relativeLeftTrans = Vector3.Subtract(processedNode.Translation, leftNode.Translation); var relativeRightTrans = Vector3.Subtract(processedNode.Translation, rightNode.Translation); if (AABB.IsOutside(processedNode.Bounds, relativeLeftTrans, leftNode.Bounds)) { if (AABB.IsOutside(processedNode.Bounds, relativeRightTrans, rightNode.Bounds)) { // When our polygons lie outside the bounds of both the left and the right node, then // all the polygons can be categorized as being 'outside' outside.AddRange(inputPolygons); } else { //Categorize(processedNode, mesh, right, // inputPolygons, // inside, aligned, revAligned, outside); categorizationNode = rightNode; goto Restart; } } else if (AABB.IsOutside(processedNode.Bounds, relativeRightTrans, rightNode.Bounds)) { //Categorize(processedNode, left, mesh, // inputPolygons, // inside, aligned, revAligned, outside); categorizationNode = leftNode; goto Restart; } else { LogicalOr(processedNode, processedMesh, categorizationNode, inputPolygons, inside, aligned, revAligned, outside, false, false); } break; } case CSGNodeType.Common: { // !(!A || !B) var relativeLeftTrans = Vector3.Subtract(processedNode.Translation, leftNode.Translation); var relativeRightTrans = Vector3.Subtract(processedNode.Translation, rightNode.Translation); if (AABB.IsOutside(processedNode.Bounds, relativeLeftTrans, leftNode.Bounds) || AABB.IsOutside(processedNode.Bounds, relativeRightTrans, rightNode.Bounds)) { // When our polygons lie outside the bounds of both the left and the right node, then // all the polygons can be categorized as being 'outside' outside.AddRange(inputPolygons); } else { LogicalOr(processedNode, processedMesh, categorizationNode, inputPolygons, outside, revAligned, aligned, inside, true, true); } break; } case CSGNodeType.Subtraction: { // !(!A || B) var relativeLeftTrans = Vector3.Subtract(processedNode.Translation, leftNode.Translation); var relativeRightTrans = Vector3.Subtract(processedNode.Translation, rightNode.Translation); if (AABB.IsOutside(processedNode.Bounds, relativeLeftTrans, leftNode.Bounds)) { // When our polygons lie outside the bounds of both the left node, then // all the polygons can be categorized as being 'outside' outside.AddRange(inputPolygons); } else if (AABB.IsOutside(processedNode.Bounds, relativeRightTrans, rightNode.Bounds)) { categorizationNode = leftNode; goto Restart; } else { LogicalOr(processedNode, processedMesh, categorizationNode, inputPolygons, outside, revAligned, aligned, inside, true, false); } break; } } }
// We cache our base meshes here public static ConcurrentDictionary <CSGNode, CSGMesh> ProcessCSGNodes(CSGNode root, IEnumerable <CSGNode> nodes) { var meshes = new ConcurrentDictionary <CSGNode, CSGMesh>(); var buildMesh = (Action <CSGNode>) delegate(CSGNode node) { CSGMesh mesh; if (node.cachedMesh == null) { // If the node we're performing csg on is a brush, we simply create the geometry from the planes // If the node is a more complicated node, we perform csg on it's child nodes and combine the // meshes that are created. // Note that right now we cache brushes per node, but we can improve on this by caching on // node type instead. Since lots of nodes will have the same geometry in real life and only // need to be created once. It won't help much in runtime performance considering they're // cached anyway, but it'll save on memory usage. if (node.NodeType != CSGNodeType.Brush) { var childNodes = CSGUtility.FindChildBrushes(node, root.Transformation.Transform); var brushMeshes = ProcessCSGNodes(node, childNodes); mesh = CSGMesh.Combine(node.Translation, brushMeshes); } else { mesh = CSGMesh.CreateFromPlanes(node.Generator.GetPlanes(node.WorldTransformation)); } // Cache the mesh node.cachedMesh = mesh; } else { mesh = node.cachedMesh; } // Clone the cached mesh so we can perform CSG on it. var clonedMesh = mesh; //.Clone(); node.Bounds.Set(clonedMesh.Bounds); meshes[node] = clonedMesh; }; var updateDelegate = (Action <KeyValuePair <CSGNode, CSGMesh> >) delegate(KeyValuePair <CSGNode, CSGMesh> item) { var processedNode = item.Key; var processedMesh = item.Value; var inputPolygons = processedMesh.Polygons; var insidePolygons = new List <Polygon>(inputPolygons.Count); var outsidePolygons = new List <Polygon>(inputPolygons.Count); var alignedPolygons = new List <Polygon>(inputPolygons.Count); var reversedPolygons = new List <Polygon>(inputPolygons.Count); CSGCategorization.Categorize(processedNode, processedMesh, root, inputPolygons, // these are the polygons that are categorized insidePolygons, alignedPolygons, reversedPolygons, outsidePolygons ); // Flag all non aligned polygons as being invisible, and store their categorizations // so we can use it if we instance this mesh. foreach (var polygon in insidePolygons) { polygon.Category = PolygonCategory.Inside; polygon.Visible = false; } foreach (var polygon in outsidePolygons) { polygon.Category = PolygonCategory.Outside; polygon.Visible = false; } foreach (var polygon in alignedPolygons) { polygon.Category = PolygonCategory.Aligned; } foreach (var polygon in reversedPolygons) { polygon.Category = PolygonCategory.ReverseAligned; } }; // // Here we run build the meshes and perform csg on them either in serial or parallel // foreach (var node in nodes) { buildMesh(node); } CSGUtility.UpdateBounds(root); foreach (var item in meshes) { updateDelegate(item); } //ProcessNode(root, root); //Parallel.ForEach(nodes, ProcessNode); //CSGUtility.UpdateBounds(root); //UpdateMesh(root, root); //Parallel.ForEach(meshes, updateDelegate); //*/ return(meshes); }
private static void UpdateMesh(CSGNode node, CSGNode root) { //if (node.Left != null) UpdateMesh(node.Left, node); //if (node.Right != null) UpdateMesh(node.Right, node); var processedNode = node; var processedMesh = node.cachedMesh; var inputPolygons = processedMesh.Polygons; var insidePolygons = new List<Polygon>(inputPolygons.Count); var outsidePolygons = new List<Polygon>(inputPolygons.Count); var alignedPolygons = new List<Polygon>(inputPolygons.Count); var reversedPolygons = new List<Polygon>(inputPolygons.Count); CSGCategorization.Categorize(processedNode, processedMesh, root, inputPolygons, // these are the polygons that are categorized insidePolygons, alignedPolygons, reversedPolygons, outsidePolygons ); // Flag all non aligned polygons as being invisible, and store their categorizations // so we can use it if we instance this mesh. foreach (var polygon in insidePolygons) { polygon.Category = PolygonCategory.Inside; polygon.Visible = false; } foreach (var polygon in outsidePolygons) { polygon.Category = PolygonCategory.Outside; polygon.Visible = false; } foreach (var polygon in alignedPolygons) polygon.Category = PolygonCategory.Aligned; foreach (var polygon in reversedPolygons) polygon.Category = PolygonCategory.ReverseAligned; }
private static void ProcessNode(CSGNode node, CSGNode root) { if (node.cachedMesh == null) { if (node.NodeType != CSGNodeType.Brush) { ProcessNode(node.Left, node); ProcessNode(node.Right, node); node.cachedMesh = CSGMesh.Combine(node.Translation, node.Left, node.Right); node.Bounds.Clear(); node.Bounds.Add(node.Left.Bounds.Translated(Vector3.Subtract(node.Left.Translation, node.Translation))); node.Bounds.Add(node.Right.Bounds.Translated(Vector3.Subtract(node.Right.Translation, node.Translation))); UpdateMesh(node, root); } else { node.cachedMesh = CSGMesh.CreateFromPlanes(node.Generator.GetPlanes(node.WorldTransformation)); node.Bounds.Set(node.cachedMesh.Bounds); } } }
// We cache our base meshes here public static ConcurrentDictionary<CSGNode, CSGMesh> ProcessCSGNodes(CSGNode root, IEnumerable<CSGNode> nodes) { var meshes = new ConcurrentDictionary<CSGNode, CSGMesh>(); var buildMesh = (Action<CSGNode>) delegate(CSGNode node) { CSGMesh mesh; if (node.cachedMesh == null) { // If the node we're performing csg on is a brush, we simply create the geometry from the planes // If the node is a more complicated node, we perform csg on it's child nodes and combine the // meshes that are created. // Note that right now we cache brushes per node, but we can improve on this by caching on // node type instead. Since lots of nodes will have the same geometry in real life and only // need to be created once. It won't help much in runtime performance considering they're // cached anyway, but it'll save on memory usage. if (node.NodeType != CSGNodeType.Brush) { var childNodes = CSGUtility.FindChildBrushes(node, root.Transformation.Transform); var brushMeshes = ProcessCSGNodes(node, childNodes); mesh = CSGMesh.Combine(node.Translation, brushMeshes); } else mesh = CSGMesh.CreateFromPlanes(node.Generator.GetPlanes(node.WorldTransformation)); // Cache the mesh node.cachedMesh = mesh; } else mesh = node.cachedMesh; // Clone the cached mesh so we can perform CSG on it. var clonedMesh = mesh;//.Clone(); node.Bounds.Set(clonedMesh.Bounds); meshes[node] = clonedMesh; }; var updateDelegate = (Action<KeyValuePair<CSGNode, CSGMesh>>) delegate(KeyValuePair<CSGNode, CSGMesh> item) { var processedNode = item.Key; var processedMesh = item.Value; var inputPolygons = processedMesh.Polygons; var insidePolygons = new List<Polygon>(inputPolygons.Count); var outsidePolygons = new List<Polygon>(inputPolygons.Count); var alignedPolygons = new List<Polygon>(inputPolygons.Count); var reversedPolygons = new List<Polygon>(inputPolygons.Count); CSGCategorization.Categorize(processedNode, processedMesh, root, inputPolygons, // these are the polygons that are categorized insidePolygons, alignedPolygons, reversedPolygons, outsidePolygons ); // Flag all non aligned polygons as being invisible, and store their categorizations // so we can use it if we instance this mesh. foreach (var polygon in insidePolygons) { polygon.Category = PolygonCategory.Inside; polygon.Visible = false; } foreach (var polygon in outsidePolygons) { polygon.Category = PolygonCategory.Outside; polygon.Visible = false; } foreach (var polygon in alignedPolygons) polygon.Category = PolygonCategory.Aligned; foreach (var polygon in reversedPolygons) polygon.Category = PolygonCategory.ReverseAligned; }; // // Here we run build the meshes and perform csg on them either in serial or parallel // foreach (var node in nodes) buildMesh(node); CSGUtility.UpdateBounds(root); foreach (var item in meshes) updateDelegate(item); //ProcessNode(root, root); //Parallel.ForEach(nodes, ProcessNode); //CSGUtility.UpdateBounds(root); //UpdateMesh(root, root); //Parallel.ForEach(meshes, updateDelegate); //*/ return meshes; }
public static void Categorize(CSGNode processedNode, CSGMesh processedMesh, CSGNode categorizationNode, List<Polygon> inputPolygons, List<Polygon> inside, List<Polygon> aligned, List<Polygon> revAligned, List<Polygon> outside) { // When you go deep enough in the tree it's possible that all categories point to the same // destination. So we detect that and potentially avoid a lot of wasted work. if (inside == revAligned && inside == aligned && inside == outside) { inside.AddRange(inputPolygons); return; } Restart: if (processedNode == categorizationNode) { // When the currently processed node is the same node as we categorize against, then // we know that all our polygons are visible and we set their default category // (usually aligned, unless it's an instancing node in which case it's precalculated) foreach (var polygon in inputPolygons) { switch (polygon.Category) { case PolygonCategory.Aligned: aligned.Add(polygon); break; case PolygonCategory.ReverseAligned: revAligned.Add(polygon); break; case PolygonCategory.Inside: inside.Add(polygon); break; case PolygonCategory.Outside: outside.Add(polygon); break; } // When brushes overlap and they share the same surface area we only want to keep // the polygons of the last brush in the tree, and skip all others. // At this point in the tree we know that this polygon belongs to this brush, so // we set it to visible. If the polygon is found to share the surface area with another // brush further on in the tree it'll be set to invisible again in mesh.Intersect. polygon.Visible = true; } return; } var leftNode = categorizationNode.Left; var rightNode = categorizationNode.Right; switch (categorizationNode.NodeType) { case CSGNodeType.Brush: { processedMesh.Intersect( categorizationNode.Bounds, categorizationNode.Generator.GetPlanes(categorizationNode.WorldTransformation), categorizationNode.Translation, processedNode.Translation, inputPolygons, inside, aligned, revAligned, outside); break; } case CSGNodeType.Addition: { // ( A || B) var relativeLeftTrans = Vector3.Subtract(processedNode.Translation, leftNode.Translation); var relativeRightTrans = Vector3.Subtract(processedNode.Translation, rightNode.Translation); if (AABB.IsOutside(processedNode.Bounds, relativeLeftTrans, leftNode.Bounds)) { if (AABB.IsOutside(processedNode.Bounds, relativeRightTrans, rightNode.Bounds)) { // When our polygons lie outside the bounds of both the left and the right node, then // all the polygons can be categorized as being 'outside' outside.AddRange(inputPolygons); } else { //Categorize(processedNode, mesh, right, // inputPolygons, // inside, aligned, revAligned, outside); categorizationNode = rightNode; goto Restart; } } else if (AABB.IsOutside(processedNode.Bounds, relativeRightTrans, rightNode.Bounds)) { //Categorize(processedNode, left, mesh, // inputPolygons, // inside, aligned, revAligned, outside); categorizationNode = leftNode; goto Restart; } else { LogicalOr(processedNode, processedMesh, categorizationNode, inputPolygons, inside, aligned, revAligned, outside, false, false); } break; } case CSGNodeType.Common: { // !(!A || !B) var relativeLeftTrans = Vector3.Subtract(processedNode.Translation, leftNode.Translation); var relativeRightTrans = Vector3.Subtract(processedNode.Translation, rightNode.Translation); if (AABB.IsOutside(processedNode.Bounds, relativeLeftTrans, leftNode.Bounds) || AABB.IsOutside(processedNode.Bounds, relativeRightTrans, rightNode.Bounds)) { // When our polygons lie outside the bounds of both the left and the right node, then // all the polygons can be categorized as being 'outside' outside.AddRange(inputPolygons); } else { LogicalOr(processedNode, processedMesh, categorizationNode, inputPolygons, outside, revAligned, aligned, inside, true, true); } break; } case CSGNodeType.Subtraction: { // !(!A || B) var relativeLeftTrans = Vector3.Subtract(processedNode.Translation, leftNode.Translation); var relativeRightTrans = Vector3.Subtract(processedNode.Translation, rightNode.Translation); if (AABB.IsOutside(processedNode.Bounds, relativeLeftTrans, leftNode.Bounds)) { // When our polygons lie outside the bounds of both the left node, then // all the polygons can be categorized as being 'outside' outside.AddRange(inputPolygons); } else if (AABB.IsOutside(processedNode.Bounds, relativeRightTrans, rightNode.Bounds)) { categorizationNode = leftNode; goto Restart; } else { LogicalOr(processedNode, processedMesh, categorizationNode, inputPolygons, outside, revAligned, aligned, inside, true, false); } break; } } }
void CreateVisualObjects(bool inSceneView = false) { CleanUp(); prevForcedGridCenter = RealtimeCSG.CSGGrid.ForcedGridCenter; prevForcedGridRotation = RealtimeCSG.CSGGrid.ForcedGridRotation; sourceSurfaceAlignment = PrefabSourceAlignment.AlignedFront; destinationSurfaceAlignment = PrefabDestinationAlignment.AlignToSurface; visualDragGameObject = new List <GameObject>(); var foundTransforms = new List <Transform>(); foreach (var obj in dragGameObjects) { foundTransforms.AddRange(obj.GetComponentsInChildren <Transform>()); CSGNode node = obj.GetComponent <CSGNode>(); if (!node) { continue; } sourceSurfaceAlignment = node.PrefabSourceAlignment; destinationSurfaceAlignment = node.PrefabDestinationAlignment; bool createCopyInsteadOfInstance = node && node.PrefabBehaviour == PrefabInstantiateBehaviour.Copy; GameObject copy = CSGPrefabUtility.Instantiate(obj, createCopyInsteadOfInstance); if (!copy) { continue; } copy.name = obj.name; visualDragGameObject.Add(copy); } ignoreTransforms = new HashSet <Transform>(foundTransforms); if (inSceneView) { var model = SelectionUtility.LastUsedModel; if (model && !containsModel) { var parent = model.transform; int counter = 0; foreach (var obj in visualDragGameObject) { if (!obj) { continue; } if (obj.activeSelf) { obj.transform.SetParent(parent, false); obj.transform.SetSiblingIndex(hoverSiblingIndex + counter); counter++; } } } } else { var parent = hoverParent; int counter = 0; foreach (var obj in visualDragGameObject) { if (!obj) { continue; } if (obj.activeSelf) { obj.transform.SetParent(parent, false); obj.transform.SetSiblingIndex(hoverSiblingIndex + counter); counter++; } } } }
public CSGNode(string id, CSGNodeType branchOperator, CSGNode left, CSGNode right) { this.NodeType = branchOperator; this.Left = left; this.Right = right; }
// Logical OR set operation on polygons // // Table showing final output from combination of categorization of left and right node // // | right node // | inside aligned r-aligned outside // -----------------+------------------------------------------ // left inside | I I I I // node aligned | I A I A // r-aligned | I I R R // outside | I A R O // // I = inside A = aligned // O = outside R = reverse aligned // #region LogicalOr static void LogicalOr(CSGNode processedNode, CSGMesh processedMesh, CSGNode categorizationNode, List <Polygon> inputPolygons, List <Polygon> inside, List <Polygon> aligned, List <Polygon> revAligned, List <Polygon> outside, bool inverseLeft, bool inverseRight) { var leftNode = categorizationNode.Left; var rightNode = categorizationNode.Right; var defaultCapacity = inputPolygons.Count / 2; // ... Allocations are ridiculously cheap in .NET, there is a garbage collection penalty however. // CSG can be performed without temporary buffers and recursion by using flags, // which would increase performance and scalability (garbage collection interfers with parallelization). // It makes the code a lot harder to read however. var leftAligned = new List <Polygon>(defaultCapacity); var leftRevAligned = new List <Polygon>(defaultCapacity); var leftOutside = new List <Polygon>(defaultCapacity); //var leftInside = new List<Polygon>(defaultCapacity); // everything that's inside the left node // is always part of the inside category // First categorize polygons in left path ... if (inverseLeft) { Categorize(processedNode, processedMesh, leftNode, inputPolygons, leftOutside, leftRevAligned, leftAligned, inside); } else { Categorize(processedNode, processedMesh, leftNode, inputPolygons, inside, leftAligned, leftRevAligned, leftOutside); } // ... Then categorize the polygons in the right path // Note that no single polygon will go into more than one of the Categorize methods below if (inverseRight) { if (leftAligned.Count > 0) { if (inside == aligned) { inside.AddRange(leftAligned); } else { Categorize(processedNode, processedMesh, rightNode, leftAligned, aligned, inside, aligned, inside); } } if (leftRevAligned.Count > 0) { if (inside == revAligned) { inside.AddRange(leftRevAligned); } else { Categorize(processedNode, processedMesh, rightNode, leftRevAligned, revAligned, revAligned, inside, inside); } } if (leftOutside.Count > 0) { Categorize(processedNode, processedMesh, rightNode, leftOutside, outside, revAligned, aligned, inside); } } else { if (leftAligned.Count > 0) { if (inside == aligned) { inside.AddRange(leftAligned); } else { Categorize(processedNode, processedMesh, rightNode, leftAligned, inside, aligned, inside, aligned); } } if (leftRevAligned.Count > 0) { if (inside == revAligned) { inside.AddRange(leftRevAligned); } else { Categorize(processedNode, processedMesh, rightNode, leftRevAligned, inside, inside, revAligned, revAligned); } } if (leftOutside.Count > 0) { Categorize(processedNode, processedMesh, rightNode, leftOutside, inside, aligned, revAligned, outside); } } }
static void LogicalOr( CSGNode processedNode, CSGMesh processedMesh, CSGNode categorizationNode, List<Polygon> inputPolygons, List<Polygon> inside, List<Polygon> aligned, List<Polygon> revAligned, List<Polygon> outside, bool inverseLeft, bool inverseRight) { var leftNode = categorizationNode.Left; var rightNode = categorizationNode.Right; var defaultCapacity = inputPolygons.Count / 2; // ... Allocations are ridiculously cheap in .NET, there is a garbage collection penalty however. // CSG can be performed without temporary buffers and recursion by using flags, // which would increase performance and scalability (garbage collection interfers with parallelization). // It makes the code a lot harder to read however. var leftAligned = new List<Polygon>(defaultCapacity); var leftRevAligned = new List<Polygon>(defaultCapacity); var leftOutside = new List<Polygon>(defaultCapacity); //var leftInside = new List<Polygon>(defaultCapacity); // everything that's inside the left node // is always part of the inside category // First categorize polygons in left path ... if (inverseLeft) Categorize(processedNode, processedMesh, leftNode, inputPolygons, leftOutside, leftRevAligned, leftAligned, inside); else Categorize(processedNode, processedMesh, leftNode, inputPolygons, inside, leftAligned, leftRevAligned, leftOutside); // ... Then categorize the polygons in the right path // Note that no single polygon will go into more than one of the Categorize methods below if (inverseRight) { if (leftAligned.Count > 0) { if (inside == aligned) { inside.AddRange(leftAligned); } else Categorize(processedNode, processedMesh, rightNode, leftAligned, aligned, inside, aligned, inside); } if (leftRevAligned.Count > 0) { if (inside == revAligned) { inside.AddRange(leftRevAligned); } else Categorize(processedNode, processedMesh, rightNode, leftRevAligned, revAligned, revAligned, inside, inside); } if (leftOutside.Count > 0) { Categorize(processedNode, processedMesh, rightNode, leftOutside, outside, revAligned, aligned, inside); } } else { if (leftAligned.Count > 0) { if (inside == aligned) { inside.AddRange(leftAligned); } else Categorize(processedNode, processedMesh, rightNode, leftAligned, inside, aligned, inside, aligned); } if (leftRevAligned.Count > 0) { if (inside == revAligned) { inside.AddRange(leftRevAligned); } else Categorize(processedNode, processedMesh, rightNode, leftRevAligned, inside, inside, revAligned, revAligned); } if (leftOutside.Count > 0) { Categorize(processedNode, processedMesh, rightNode, leftOutside, inside, aligned, revAligned, outside); } } }
public CSGNode(string id, CSGNodeType branchOperator) { this.NodeType = branchOperator; this.Left = null; this.Right = null; }