Merge branch 'master' of https://github.com/Nition/UnityOctree

Author: Nition

README.md

@@ -17,7 +17,7 @@ There are two octree implementations here:
 **A few functions are implemented:**
 
 With BoundsOctree, you can pass in bounds and get a true/false answer for if it's colliding with anything (IsColliding), or get a list of everything it's collising with (GetColliding).
-With PointOctree, you can cast a ray and get a list of objects that are within x distance of that ray (GetNearby).
+With PointOctree, you can cast a ray and get a list of objects that are within x distance of that ray (GetNearby). You may also get a list of objects that are within x distance from a specified origin point.
 
 It shouldn't be too hard to implement additional functions if needed. For instance, PointOctree could check for points that fall inside a given bounds.
 
@@ -79,6 +79,11 @@ pointTree.GetNearby(myRay, 4);
 - Where myRay is a [Ray](http://docs.unity3d.com/Documentation/ScriptReference/Ray.html)
 - In this case we're looking for any point within 4m of the closest point on the ray
 
+```C#
+pointTree.GetNearby(myPos, 4);
+```
+- Where myPos is a [Vector3](http://docs.unity3d.com/Documentation/ScriptReference/Vector3.html)
+
 **Debugging Visuals**
 
 ![Visualisation example.](https://raw.github.com/nition/UnityOctree/master/octree-visualisation.jpg)

Scripts/BoundsOctree.cs

@@ -24,14 +24,17 @@
 public class BoundsOctree<T> {
 	// The total amount of objects currently in the tree
 	public int Count { get; private set; }
-	
+
 	// Root node of the octree
 	BoundsOctreeNode<T> rootNode;
+
 	// Should be a value between 1 and 2. A multiplier for the base size of a node.
 	// 1.0 is a "normal" octree, while values > 1 have overlap
 	readonly float looseness;
+
 	// Size that the octree was on creation
 	readonly float initialSize;
+
 	// Minimum side length that a node can be - essentially an alternative to having a max depth
 	readonly float minSize;
 	// For collision visualisation. Automatically removed in builds.
@@ -97,6 +100,24 @@ public bool Remove(T obj) {
 		return removed;
 	}
 
+	/// <summary>
+	/// Removes the specified object at the given position. Makes the assumption that the object only exists once in the tree.
+	/// </summary>
+	/// <param name="obj">Object to remove.</param>
+	/// <param name="objBounds">3D bounding box around the object.</param>
+	/// <returns>True if the object was removed successfully.</returns>
+	public bool Remove(T obj, Bounds objBounds) {
+		bool removed = rootNode.Remove(obj, objBounds);
+
+		// See if we can shrink the octree down now that we've removed the item
+		if (removed) {
+			Count--;
+			Shrink();
+		}
+
+		return removed;
+	}
+
 	/// <summary>
 	/// Check if the specified bounds intersect with anything in the tree. See also: GetColliding.
 	/// </summary>
@@ -153,8 +174,7 @@ public void GetColliding(List<T> collidingWith, Ray checkRay, float maxDistance
 		rootNode.GetColliding(ref checkRay, collidingWith, maxDistance);
 	}
 
-	public Bounds GetMaxBounds()
-	{
+	public Bounds GetMaxBounds() {
 		return rootNode.GetBounds();
 	}
 
@@ -244,19 +264,15 @@ void Grow(Vector3 direction) {
 		// Create a new, bigger octree root node
 		rootNode = new BoundsOctreeNode<T>(newLength, minSize, looseness, newCenter);
 
-		if (oldRoot.HasAnyObjects())
-		{
+		if (oldRoot.HasAnyObjects()) {
 			// Create 7 new octree children to go with the old root as children of the new root
 			int rootPos = GetRootPosIndex(xDirection, yDirection, zDirection);
 			BoundsOctreeNode<T>[] children = new BoundsOctreeNode<T>[8];
-			for (int i = 0; i < 8; i++)
-			{
-				if (i == rootPos)
-				{
+			for (int i = 0; i < 8; i++) {
+				if (i == rootPos) {
 					children[i] = oldRoot;
 				}
-				else
-				{
+				else {
 					xDirection = i % 2 == 0 ? -1 : 1;
 					yDirection = i > 3 ? -1 : 1;
 					zDirection = (i < 2 || (i > 3 && i < 6)) ? -1 : 1;

Scripts/BoundsOctreeNode.cs

@@ -6,23 +6,31 @@
 public class BoundsOctreeNode<T> {
 	// Centre of this node
 	public Vector3 Center { get; private set; }
+
 	// Length of this node if it has a looseness of 1.0
 	public float BaseLength { get; private set; }
 
 	// Looseness value for this node
 	float looseness;
+
 	// Minimum size for a node in this octree
 	float minSize;
+
 	// Actual length of sides, taking the looseness value into account
 	float adjLength;
+
 	// Bounding box that represents this node
 	Bounds bounds = default(Bounds);
+
 	// Objects in this node
 	readonly List<OctreeObject> objects = new List<OctreeObject>();
+
 	// Child nodes, if any
 	BoundsOctreeNode<T>[] children = null;
+
 	// Bounds of potential children to this node. These are actual size (with looseness taken into account), not base size
 	Bounds[] childBounds;
+
 	// If there are already numObjectsAllowed in a node, we split it into children
 	// A generally good number seems to be something around 8-15
 	const int numObjectsAllowed = 8;
@@ -92,6 +100,19 @@ public bool Remove(T obj) {
 		return removed;
 	}
 
+	/// <summary>
+	/// Removes the specified object at the given position. Makes the assumption that the object only exists once in the tree.
+	/// </summary>
+	/// <param name="obj">Object to remove.</param>
+	/// <param name="objBounds">3D bounding box around the object.</param>
+	/// <returns>True if the object was removed successfully.</returns>
+	public bool Remove(T obj, Bounds objBounds) {
+		if (!Encapsulates(bounds, objBounds)) {
+			return false;
+		}
+		return SubRemove(obj, objBounds);
+	}
+
 	/// <summary>
 	/// Check if the specified bounds intersect with anything in the tree. See also: GetColliding.
 	/// </summary>
@@ -223,8 +244,7 @@ public void SetChildren(BoundsOctreeNode<T>[] childOctrees) {
 		children = childOctrees;
 	}
 
-	public Bounds GetBounds()
-	{
+	public Bounds GetBounds() {
 		return bounds;
 	}
 
@@ -446,6 +466,37 @@ void SubAdd(T obj, Bounds objBounds) {
 		}
 	}
 
+	/// <summary>
+	/// Private counterpart to the public <see cref="Remove(T, Bounds)"/> method.
+	/// </summary>
+	/// <param name="obj">Object to remove.</param>
+	/// <param name="objBounds">3D bounding box around the object.</param>
+	/// <returns>True if the object was removed successfully.</returns>
+	bool SubRemove(T obj, Bounds objBounds) {
+		bool removed = false;
+
+		for (int i = 0; i < objects.Count; i++) {
+			if (objects[i].Obj.Equals(obj)) {
+				removed = objects.Remove(objects[i]);
+				break;
+			}
+		}
+
+		if (!removed && children != null) {
+			int bestFitChild = BestFitChild(objBounds);
+			removed = children[bestFitChild].SubRemove(obj, objBounds);
+		}
+
+		if (removed && children != null) {
+			// Check if we should merge nodes now that we've removed an item
+			if (ShouldMerge()) {
+				Merge();
+			}
+		}
+
+		return removed;
+	}
+
 	/// <summary>
 	/// Splits the octree into eight children.
 	/// </summary>

Scripts/PointOctree.cs

@@ -17,11 +17,13 @@
 public class PointOctree<T> where T : class {
 	// The total amount of objects currently in the tree
 	public int Count { get; private set; }
-	
+
 	// Root node of the octree
 	PointOctreeNode<T> rootNode;
+
 	// Size that the octree was on creation
 	readonly float initialSize;
+
 	// Minimum side length that a node can be - essentially an alternative to having a max depth
 	readonly float minSize;
 
@@ -79,6 +81,40 @@ public bool Remove(T obj) {
 		return removed;
 	}
 
+	/// <summary>
+	/// Removes the specified object at the given position. Makes the assumption that the object only exists once in the tree.
+	/// </summary>
+	/// <param name="obj">Object to remove.</param>
+	/// <param name="objPos">Position of the object.</param>
+	/// <returns>True if the object was removed successfully.</returns>
+	public bool Remove(T obj, Vector3 objPos) {
+		bool removed = rootNode.Remove(obj, objPos);
+
+		// See if we can shrink the octree down now that we've removed the item
+		if (removed) {
+			Count--;
+			Shrink();
+		}
+
+		return removed;
+	}
+
+	/// <summary>
+	/// Returns objects that are within maxDistance of the specified ray.
+	/// If none returns false. Uses supplied list for results.
+	/// </summary>
+	/// <param name="ray">The ray. Passing as ref to improve performance since it won't have to be copied.</param>
+	/// <param name="maxDistance">Maximum distance from the ray to consider</param>
+	/// <param name="nearBy">Pre-initialized list to populate</param>
+	/// <returns>True if items are found, false if not</returns>
+	public bool GetNearbyNonAlloc(Ray ray, float maxDistance, List<T> nearBy) {
+		nearBy.Clear();
+		rootNode.GetNearby(ref ray, ref maxDistance, nearBy);
+		if (nearBy.Count > 0)
+			return true;
+		return false;
+	}
+
 	/// <summary>
 	/// Return objects that are within maxDistance of the specified ray.
 	/// If none, returns an empty array (not null).
@@ -92,6 +128,30 @@ public T[] GetNearby(Ray ray, float maxDistance) {
 		return collidingWith.ToArray();
 	}
 
+	/// <summary>
+	/// Return objects that are within <paramref name="maxDistance"/> of the specified position.
+	/// If none, returns an empty array (not null).
+	/// </summary>
+	/// <param name="position">The position. Passing as ref to improve performance since it won't have to be copied.</param>
+	/// <param name="maxDistance">Maximum distance from the ray to consider.</param>
+	/// <returns>Objects within range.</returns>
+	public T[] GetNearby(Vector3 position, float maxDistance) {
+		List<T> collidingWith = new List<T>();
+		rootNode.GetNearby(ref position, ref maxDistance, collidingWith);
+		return collidingWith.ToArray();
+	}
+
+	/// <summary>
+	/// Return all objects in the tree.
+	/// If none, returns an empty array (not null).
+	/// </summary>
+	/// <returns>All objects.</returns>
+	public ICollection<T> GetAll() {
+		List<T> objects = new List<T>(Count);
+		rootNode.GetAll(objects);
+		return objects;
+	}
+
 	/// <summary>
 	/// Draws node boundaries visually for debugging.
 	/// Must be called from OnDrawGizmos externally. See also: DrawAllObjects.