Question

I’m currently working on a collision detection algorithm with a broad phase to detect possible collisions and a fine phase to do deterministic resolution of collisions. The broad phase is based on a hierarchical hash grid and is performing well.

The fine phase is based on a custom algorithm and is working with n-body collisions. In order to accurately resolve more than 2-body collisions, I will however need to somehow register all collisions and the corresponding elements in collision sets.

What would be the best way to save collisions in some way during the broad phase in order to iterate through the collisions sets in the fine phase? I was thinking along the lines of certain data structures, but I couldn’t come up with an ideal solution yet.

Answer 1

My current approach

After thinking about the problem a bit longer, I decided to try the following approach.

• collision sets are vectors of elements
• the collision sets themselves are stored in a list
• every element points to its collision set in a hashmap

If a collision is now detected during the broad phase:

1. If neither element is a key in the hashmap:
   • a new vector is created for the collision set
   • both elements are added to the collision set
   • the collision set is added to the collision list
   • both elements are inserted into the hashmap as key to the collision set
2. If one element is a key in the hashmap:
   • the collision set is retrieved through that element
   • the other element is added to the collision set
   • the other element is inserted into the hashmap as a key to the collision set
3. If both elements are a key in the hashmap:
   • if they are both pointing to the same collision set, it’s OK
   • if they point to different collision sets
     • create new collision set vector
     • copy both collision sets into new colision set
     • remove both collision sets from collision list
     • add new collision set to collision list
     • iterate through new collision set and update reference in hashmap for each element

In the fine phase, I can now simply iterate over all collision sets in the collision list and do exact collision resolution.

The solution is rather fast, but I’m a bit worried about the memory foot print. I will have to do a couple of benchmarks to know more.