public void AppendIntoList(FastLinkedList <T> list) { if (list == null) { return; } if (list._First == null) { return; } if (_First == null) { _First = list._First; _Last = list._Last; } else { Node temp = _Last; _Last.Next = list._First; _Last.Next.Previous = _Last; _Last = list._Last; if (_Last.Previous == null) { _Last.Previous = temp; } } length = list.length + length; }
/** * Remove the triangles in @triangles that are completely inside the geometry contained * by this BSPTree instance. Triangles that are partially inside the geometry are clipped * against it. * * If @clipLessThan is false, the operation is reversed and triangles portions outside the geometry * of this BSPTree instance are removed. */ public void ClipOutTriangles(FastLinkedList <Triangle> triangles, bool clipLessThan = true, IList <Triangle> discarded = null) { // ensure the root node exists if (root == null) { return; } // call the private, recursive version of ClipOutTriangles ClipOutTriangles(root, triangles, clipLessThan, discarded); }
public void CopyInto(IList <T> copy) { if (copy == null) { return; } FastLinkedList <T> .Node current = First; while (current != null) { copy.Add(current.Value); current = current.Next; } }
/** * Rescursive version of AddTriangles. This method partitions the triangles * in @triangles using @node's split plane, and then recursively calls itself * with the resulting greater-than and less-than lists. */ private void AddTriangles(Node node, FastLinkedList <Triangle> triangles) { if (triangles == null) { return; } if (node == null) { return; } // get a reference to the list of triangles that are co-planar with // @node's split plane FastLinkedList <Triangle> nodeTriangles = node.GetTriangleList(); FastLinkedList <Triangle> lessThan = new FastLinkedList <Triangle>(); FastLinkedList <Triangle> greaterThan = new FastLinkedList <Triangle>(); // iterate through each triangle in @triangles and classify/partition each according // @node's split plane. co-planar triangles go into @nodeTriangles, triangles on the front // side go into @greaterThan, traingles on the back side go into @lessThan. triangles.Iterate((Triangle tri) => { Partitioner.Orientation orient = Partitioner.SliceTriangle(tri, node.SplitPlane, lessThan, greaterThan, nodeTriangles, nodeTriangles); }); // release clear memory occupied by @triangles triangles.Clear(); // recurse on the back side of @node's split plane if (lessThan.First != null) { if (node.LessThan == null) { node.LessThan = Node.Create(lessThan.First.Value.OrientationPlane); } AddTriangles(node.LessThan, lessThan); } // recurse on the front side of @node's split plane if (greaterThan.First != null) { if (node.GreaterThan == null) { node.GreaterThan = Node.Create(greaterThan.First.Value.OrientationPlane); } AddTriangles(node.GreaterThan, greaterThan); } }
/** * Invert this Node instances's split plane and triangles. */ public void Invert() { FastLinkedList <Triangle> .Node current = triangles.First; while (current != null) { current.Value.Invert(); current = current.Next; } SplitPlane.Invert(); Node tempList = LessThan; LessThan = GreaterThan; GreaterThan = tempList; }
/** * Add the triangles from @triangles into this BSPTree instance. */ public void AddTriangles(List <Triangle> triangles) { if (triangles == null || triangles.Count <= 0) { return; } // ensure the root node exists if (root == null) { root = Node.Create(triangles[0].OrientationPlane); } // convert @triangles to a FastLinkedList structure. FastLinkedList <Triangle> linkedTriangles = new FastLinkedList <Triangle>(); linkedTriangles.CopyFrom(triangles); // call the private, recursive version of AddTriangles AddTriangles(root, linkedTriangles); }
private Node() { LessThan = null; GreaterThan = null; triangles = new FastLinkedList <Triangle>(); }
/** * Recursive version of ClipOutTriangles. This method partitions the triangles * in @triangles using @node's split plane, and then recursively calls itself * with the resulting greater-than and less-than lists. If the recursion reaches a * point where triangles in @triangles are on the back side of @node's split plane, * but this instance of BSPTree contains no geometry on that side (node.LessThan == null), * then the triangles placed in @lessThan are deleted from @triangles. This removes * the portions of triangles in @triangles that lie inside the geometry of this BSPTree * instance. * * If @clippLessThan is false, then we perform the reverse of the above oepration. * Triangles placed in @greaterThan than are removed when node.GreaterThan == null. * In that case the portions of triangles in @triangles that lie outside the geometry * of this BSPTree instance are removed. */ private void ClipOutTriangles(Node node, FastLinkedList <Triangle> triangles, bool clipLessThan = true, IList <Triangle> discarded = null) { if (triangles == null || triangles.First == null) { return; } if (node == null) { return; } FastLinkedList <Triangle> lessThan = new FastLinkedList <Triangle>(); FastLinkedList <Triangle> greaterThan = new FastLinkedList <Triangle>(); // iterate through each triangle in @triangles and classify/partition each according // @node's split plane. triangles on the front side go into @greaterThan, triangles // on the back side go into @lessThan. co-planar triangles whose normal matches that of // @node's split plane go into @greaterThan; the rest go into @lessThan. triangles.Iterate((Triangle tri) => { Partitioner.Orientation orient = Partitioner.SliceTriangle(tri, node.SplitPlane, lessThan, greaterThan, lessThan, greaterThan, true); }); // release memory used by @triangles triangles.Clear(); // recurse on the back side of @node's split plane if this BSPTree contains // geometry on that side. if it does not, and we want to clip out triangles // inside this BSPTree's geometry (@clipLessThan == true), then we clear out @lessThan. if (node.LessThan != null) { ClipOutTriangles(node.LessThan, lessThan, clipLessThan, discarded); } else if (clipLessThan) { if (discarded != null) { lessThan.CopyInto(discarded); } lessThan.Clear(); } // recurse on the front side of @node's split plane if this BSPTree contains // geometry on that side. if it does not, and we want to clip out triangles // outside this BSPTree's geometry (@clipLessThan == false), then we clear out @greaterThan. if (node.GreaterThan != null) { ClipOutTriangles(node.GreaterThan, greaterThan, clipLessThan, discarded); } else if (!clipLessThan) { if (discarded != null) { greaterThan.CopyInto(discarded); } greaterThan.Clear(); } // rebuild @triangles with the properly clipped triangles triangles.AppendIntoList(lessThan); triangles.AppendIntoList(greaterThan); }