What is a good algorithm to detect collision between moving spheres?

Question

If (for the purpose of collision detection) 3D objects are represented in a game by spheres, what is a good algorithm to detect a collision between spheres?

If each object has a position as of the last frame and a new (desired) position, what is a good algorithm that will identify collisions where the spheres didn't intersect in the previous frame, and they may not intersect in the second frame, but they did intersect somewhere in between?

There is [article about deriving collision detection with math on Flipcode][1]. It has circle-cirle. There is how to detect precisely the point of collision and check if there is a collision at all. [1]:http://www.flipcode.com/archives/Theory_Practice-Issue_01_Collision_Detection.shtml — user712092, Jul 04 '11 at 15:39

score 19 · Accepted Answer · answered Jul 14 '10 at 23:58

19

Basically you're looking for a trace.

This page will probably help you: http://www.realtimerendering.com/intersections.html

Moving Sphere/Sphere: (location) Add the radius of the moving sphere to the static sphere, and treat the moving sphere as a ray. Use this ray to perform ray/sphere intersection. See Gomez; Schroeder for code (article has bug in derivation, code is fine); and RTR2, p. 622.

answered Jul 14 '10 at 23:58

Tetrad

30,124
12
94
143

1

That doesn't work if both spheres move, (not even if you do it twice). Seems to me that you'd have to first do a distance check between the lines spanning movement a and the one spanning movement b, and if that is less than radius a + radius b you have a possible collision. After that I would do a check to see where that point is in time for sphere a and where for sphere b to see if the times are close. If so I'd check speed against distance in time for that point, if it's still a possible collision I'd do a stepwise refinement. – Kaj Aug 19 '10 at 07:02
18

Actually it does, you just have to make the movement relative. So if both spheres are moving you just subtract the velocity of one of the spheres from both of them so you have one "moving" sphere and one "stationary" sphere. Then you can use the above. – Tetrad Nov 23 '10 at 17:37

score 8 · Answer 2 · edited Feb 08 '23 at 00:51

8

Use a sweep test as demonstrated in this Gamasutra article. (Or the port to gamedeveloper.com...)

edited Feb 08 '23 at 00:51

Vaillancourt

16,325
17
55
61

answered Jul 15 '10 at 00:02

Firas Assaad

3,544
2
32
26

score 5 · Answer 3 · edited May 23 '17 at 12:37

Off the top of my head:

Create two line segments from the middle of each circle from where it started to where it moved to in that time step.
Find the min distance between those two line segments; as is explained here.
If that distance is less than or equal to the radius of the first circle plus the second then they collided; otherwise they did not.

And that is all there is to it, I would expect that to be pretty fast.

halt9k · Answer 4 · 2023-02-08T16:37:53.580

Answers here well explained the concept, but seems code answer was not posted yet:

// predicts collision time between two moving objects
// objects are spheres moving in 3D space with constant velocities
// returns PositiveInfinity if collision will never happen
float GetCollisionTime(WorldObject a, WorldObject b)
    {
    // relative velocity and position
    var rel_v = a.Velocity - b.Velocity;
    var rel_pos = a.Position - b.Position;
float start_dist_squared = rel_pos.LengthSquared();
double need_dist_squared = M.Pow(a.Radius + b.Radius, 2);

// skip if already collide
if (start_dist_squared &lt;= need_dist_squared)
    return 0;

float rel_dot = Vector3.Dot(rel_pos, rel_v);
float rel_v_squared = rel_v.LengthSquared();

// skip if they move away
if (rel_dot &gt; 0 || rel_v_squared == 0)
    return float.PositiveInfinity;

float min_dist_t = -rel_dot / rel_v_squared;
float min_dist_squared = (rel_pos + rel_v * min_dist_t).LengthSquared();

// skip if they never touch
if (min_dist_squared &gt; need_dist_squared)
    return float.PositiveInfinity;

double collide_dist_to_min_squared = need_dist_squared - min_dist_squared;
float collide_t_before_min = (float)M.Sqrt(collide_dist_to_min_squared / rel_v_squared);

return min_dist_t - collide_t_before_min;
}

Squared distances are used only to optimize out slow root calculations.

TarmoPikaro · Answer 5 · 2018-11-23T04:37:32.923

0

Collision detection for moving object is typically called "Swept volume calculation", here are some codes / articles about this subject.

http://www.gpu-voxels.org/demos/ (Demo)

Source code libraries:

https://github.com/fzi-forschungszentrum-informatik/gpu-voxels

https://libigl.github.io/tutorial/#swept-volume

https://github.com/gradientspace/geometry3Sharp

Articles:

http://gamma.cs.unc.edu/SV/sm03.pdf

https://www.cs.columbia.edu/~allen/PAPERS/abrams.swept.pdf (No source code unfortunately)

http://www.realtimerendering.com/intersections.html (Rather heavy collection of links)

edited Nov 23 '18 at 04:37

answered Nov 22 '18 at 21:35

TarmoPikaro

109
3

1

Answers that contain only a link (or in this case, several) do not contain an actual answer. You should include the relevant information in your post so that if those links go dead, your post is still understandable. – Draco18s no longer trusts SE Nov 23 '18 at 04:54
Information behind links slightly better explain than me at the moment. There is also demo videos behind links, which gives some perception about what is happening in real time. – TarmoPikaro Nov 23 '18 at 05:39
1

https://meta.stackexchange.com/a/8259/313685 – Draco18s no longer trusts SE Nov 23 '18 at 14:27

score -3 · Answer 6 · answered Jul 16 '10 at 09:24

-3

Speaking as someone who's done this: it's not worth the hassle. Unless your game design absolutely needs it, and it almost certainly doesn't, you'll spend far more effort getting sweeping working than you really expect. And it will be slower than you wanted it to be.

answered Jul 16 '10 at 09:24

ZorbaTHut

11,580
1
37
44

1

He could be making a pool game for all you know. – Kaj Aug 19 '10 at 07:03
1

If he was making a pool game his "game design absolutely needs it". – deft_code Nov 24 '10 at 19:11
You are right, don't reinvent the wheel. But just for excersise it may be worth it. – user712092 Jul 04 '11 at 15:34
6

I disagree with direct discouragement as an answer. – bobobobo Aug 27 '11 at 00:53
1

I agree with @bobobobo, the question is not if it's worth the hassle or not, a future user that sees this thread might absolutely need the answer no matter the cost. This would be better as a comment. – Tom Tsagkatos Nov 23 '18 at 10:02

What is a good algorithm to detect collision between moving spheres?

6 Answers6

Linked