Thanks for the excellent article with very readable code to boot! I am curious about a few things at the moment…

I am planning to use a quad tree for collision detection and and considering pre-partitioning the tree as to not require many objects to be created during run-time. That being said, would all objects have to be in leaf nodes of the tree for this to be feasible, or could the larger sized objects remain in higher level nodes, while smaller ones exist in leaf nodes? I am not sure if the question actually makes sense, but it is something that I am trying to work through semantically at the moment. Thanks again!

-Josh

Some sort of tree structure would probably work well, especially if things aren’t moving a lot (meaning you can optimize the tree for querying).

You could also keep the objects in a list sorted on X, and then grab all objects between the left and right side of the viewport, and then prune out objects above the top or below the bottom of the viewport. Whenever your viewport moved, you could add items in the new area (newViewport - oldViewport) to the visible list, and prune items from the list that aren’t visible anymore. That might be faster than a QuadTree for your purposes (Though some combination of the two methods might be even faster).

Thanks!
Todd Wilder

1) Basically, when an object is on a boundary, it will be returned as if it were in the level above (e.g. a box on a boundary of two level-2 areas will be returned for the encompassing level 1 area above it). In this case, it may be that when querying for an object in the bottom-right box, you get some object that’s on the top-middle, since it’s on the level above it. A pretty simple IsNear check can help you cull those, though.

2) Well, lets see. If you mean you’ll have to find all objects in all nodes every time and move them around, then no. If you set up a two-way relationship, objects can notify the tree-node they’re in when they need to be moved, and that tree node can communicate with its parent and children to help move the object. You’re switching data around a lot, yes, but if you program it cleverly, it shouldn’t be a huge issue (my example is programmed for understanding, not best practices!)

If you’re talking about the tree being restructured and items moving around a lot, then yes, and this is the biggest problem with quadtrees (at least with mine!). The QuadTree is constantly updating its structure as objects move through it, creating lots of nodes that will most of the time be empty (i.e. wasted space). If you don’t remove nodes (or remove them only after they’ve been stale for a while - like garbage collecting) you won’t have as much of a problem with QuadTree nodes. However, dynamic data structures can be a mess on the Xbox, because of the garbage collection, so if you’re implementing a QuadTree for the Xbox, I suggest you:
a) Use structs for anything that’s going to change a lot, since they don’t allocate on the heap.
b) Use arrays instead of lists, so you don’t have the problem of dynamic list garbage.
Basically, how you implement the QuadTree depends on your needs. I mentioned in the comments here that you could also just pre-allocate the entire tree structure so you don’t have the tree changing at all during execution.

So basically, there’s no silver bullet for Quadtrees - you’re going to have to make it suit your needs, and make sure you really need a Quadtree.

1) You said: “However, if there was an object on the middle line on the left (at level 1)”. I’m not sure which “middle line on the left” you’re referring to. Could you clarify this a bit?

2) Just to be clear, as object positions change, the quad tree will have to update their place in the tree, right? If you have a ton of objects moving around (as in the hypothetical massively-multiplayer Pong game), wouldn’t this cause a lot of churn inside the quad tree? It seems as though the quad tree would become stale with every game update, and would essentially need to be re-examined every frame. Is this true?

Sorry I didn’t respond earlier - I’ve been busying myself so much and haven’t looked at my website lately!

As to your question: you’re most likely experiencing an issue with allocating nodes in the tree…especially if you’re moving that many things around at once, and ESPECIALLY if you’re running this on the Xbox. While a Quadtree can handle that many objects, mine isn’t optimized enough to do so gracefully.

The easy method would be to pre-divide all Quadtree nodes so you don’t have to allocate anything while inserting / moving items (for any real-life situation I’d actually recommend this) - but you still end up with really deep leaves, which can take time to traverse, especially in the event that you resize your world (since my Quadtree uses a very naive resizing algorithm where it just rebuilds the whole thing).

Alternatively, you can increase the leaf size, so you can put more items in a node before it divides. You still end up with the same problem though.

I’d suggest making markers at every 100 objects or so and see how the Quadtree is dividing. Quadtrees handle distributed data really well - but when objects clump up is when Quadtrees have problems…especially on object boundaries.

I dunno - I’d need to know more about what you’re doing to really help you come up with a better solution.

I want to thank you for the explaination of the quadtrees - it helped me out very much. I still have a performance question:
I want to add about 3000 objects to the tree and it gets stuck, it seems to do nothing anymore, could there be an error? I thought it would be no problem to handle this amount of objects (=parents, right?).
Well, I think it is a problem that many nodes get pushed down during time and this is costly. Is there a good way to optimize this?

Thanks in advance,
Bye, Tom

Random _rand = new Random(DateTime.Now.Second);
QuadTree<string> m_qt = new QuadTree<string>(new Point(100, 100), 500);

//populate quadtree
for (int i= 0; i < 500; i++)
{
m_qt.Insert(new QuadTreePositionItem<string>(Guid.NewGuid().ToString(),
new Point(_rand.Next(0, 100), _rand.Next(0, 100)),
new Point(10, 10)));
}

List<QuadTreePositionItem<string>> _resultList = new List<QuadTreePositionItem<string>>();
Point _point;

//get rectangle for 20 randomly generated points
for (int i= 0; i < 20; i++)
{
_point = new Point(_rand.Next(0, 100), _rand.Next(0, 100));

m_qt.GetItems(_point, ref _resultList);

Trace.WriteLine(”———————–”);
Trace.WriteLine(”Point: ” + _point);

foreach (QuadTreePositionItem<string> item in _resultList)
{
Trace.WriteLine(”rect: ” + item.Position);
}
}