在Stack Overflow社区的帮助下，我编写了一个非常基本但有趣的物理模拟器。
你点击并拖动鼠标来发射一个球。它会弹来弹去，最终停在“地板”上。
我想添加的下一个重要功能是球与球的碰撞。球的运动被分解成x和y速度向量。有重力(每一步y向量都有小幅度的减小)，有摩擦力(每一次与墙碰撞两个向量都有小幅度的减小)。这些球以一种令人惊讶的真实方式移动。
我想我的问题有两部分:
检测球与球碰撞的最佳方法是什么?
我只是有一个O(n²)循环，遍历每个球，并检查每个球的半径是否重叠?
我用什么方程来处理球与球的碰撞?101年物理
它如何影响两个球的速度x/y向量?这两个球最终的方向是什么?我怎么把它应用到每个球上呢?
处理“墙壁”的碰撞检测和由此产生的矢量变化很容易，但我发现球-球碰撞更复杂。对于墙，我只需要取适当的x或y向量的负数，它就会朝着正确的方向移动。我可不这么认为。
一些快速的澄清:为了简单起见，我现在对完美弹性碰撞没有问题，而且我所有的球现在都有相同的质量，但未来我可能会改变这一点。
编辑:我发现有用的资源
带矢量的二维球物理:不含三角函数的二维碰撞。pdf
2d球碰撞检测示例:添加碰撞检测
成功!
我的球碰撞检测和响应工作得很好!
相关代码:
碰撞检测:
for (int i = 0; i < ballCount; i++)
{
for (int j = i + 1; j < ballCount; j++)
{
if (balls[i].colliding(balls[j]))
{
balls[i].resolveCollision(balls[j]);
}
}
}
这将检查每个球之间的碰撞，但跳过多余的检查(如果你必须检查球1是否与球2碰撞，那么你不需要检查球2是否与球1碰撞。此外，它跳过检查与自身的碰撞)。
然后，在我的球类中，我有我的collision()和resolveccollision()方法:
public boolean colliding(Ball ball)
{
float xd = position.getX() - ball.position.getX();
float yd = position.getY() - ball.position.getY();
float sumRadius = getRadius() + ball.getRadius();
float sqrRadius = sumRadius * sumRadius;
float distSqr = (xd * xd) + (yd * yd);
if (distSqr <= sqrRadius)
{
return true;
}
return false;
}
public void resolveCollision(Ball ball)
{
// get the mtd
Vector2d delta = (position.subtract(ball.position));
float d = delta.getLength();
// minimum translation distance to push balls apart after intersecting
Vector2d mtd = delta.multiply(((getRadius() + ball.getRadius())-d)/d);
// resolve intersection --
// inverse mass quantities
float im1 = 1 / getMass();
float im2 = 1 / ball.getMass();
// push-pull them apart based off their mass
position = position.add(mtd.multiply(im1 / (im1 + im2)));
ball.position = ball.position.subtract(mtd.multiply(im2 / (im1 + im2)));
// impact speed
Vector2d v = (this.velocity.subtract(ball.velocity));
float vn = v.dot(mtd.normalize());
// sphere intersecting but moving away from each other already
if (vn > 0.0f) return;
// collision impulse
float i = (-(1.0f + Constants.restitution) * vn) / (im1 + im2);
Vector2d impulse = mtd.normalize().multiply(i);
// change in momentum
this.velocity = this.velocity.add(impulse.multiply(im1));
ball.velocity = ball.velocity.subtract(impulse.multiply(im2));
}
源代码:完整的源球到球对撞机。
如果有人对如何改进这个基本物理模拟器有一些建议，请告诉我!我还需要补充的一件事是角动量，这样球就会滚动得更真实。还有其他建议吗?请留下评论!
这是一个支持质量的简单例子。
private void CollideBalls(Transform ball1, Transform ball2, ref Vector3 vel1, ref Vector3 vel2, float radius1, float radius2)
{
var vec = ball1.position - ball2.position;
float dis = vec.magnitude;
if (dis < radius1 + radius2)
{
var n = vec.normalized;
ReflectVelocity(ref vel1, ref vel2, ballMass1, ballMass2, n);
var c = Vector3.Lerp(ball1.position, ball2.position, radius1 / (radius1 + radius2));
ball1.position = c + (n * radius1);
ball2.position = c - (n * radius2);
}
}
public static void ReflectVelocity(ref Vector3 vel1, ref Vector3 vel2, float mass1, float mass2, Vector3 intersectionNormal)
{
float velImpact1 = Vector3.Dot(vel1, intersectionNormal);
float velImpact2 = Vector3.Dot(vel2, intersectionNormal);
float totalMass = mass1 + mass2;
float massTransfure1 = mass1 / totalMass;
float massTransfure2 = mass2 / totalMass;
vel1 += ((velImpact2 * massTransfure2) - (velImpact1 * massTransfure2)) * intersectionNormal;
vel2 += ((velImpact1 * massTransfure1) - (velImpact2 * massTransfure1)) * intersectionNormal;
}
To detect whether two balls collide, just check whether the distance between their centers is less than two times the radius. To do a perfectly elastic collision between the balls, you only need to worry about the component of the velocity that is in the direction of the collision. The other component (tangent to the collision) will stay the same for both balls. You can get the collision components by creating a unit vector pointing in the direction from one ball to the other, then taking the dot product with the velocity vectors of the balls. You can then plug these components into a 1D perfectly elastic collision equation.
维基百科对整个过程有一个很好的总结。对于任何质量的球，新的速度可以用以下公式计算(其中v1和v2是碰撞后的速度，u1和u2是碰撞前的速度):
如果两个球质量相同，那么速度只是互换。下面是我写的一些类似的代码:
void Simulation::collide(Storage::Iterator a, Storage::Iterator b)
{
// Check whether there actually was a collision
if (a == b)
return;
Vector collision = a.position() - b.position();
double distance = collision.length();
if (distance == 0.0) { // hack to avoid div by zero
collision = Vector(1.0, 0.0);
distance = 1.0;
}
if (distance > 1.0)
return;
// Get the components of the velocity vectors which are parallel to the collision.
// The perpendicular component remains the same for both fish
collision = collision / distance;
double aci = a.velocity().dot(collision);
double bci = b.velocity().dot(collision);
// Solve for the new velocities using the 1-dimensional elastic collision equations.
// Turns out it's really simple when the masses are the same.
double acf = bci;
double bcf = aci;
// Replace the collision velocity components with the new ones
a.velocity() += (acf - aci) * collision;
b.velocity() += (bcf - bci) * collision;
}
至于效率，Ryan Fox是对的，您应该考虑将区域划分为部分，然后在每个部分中进行碰撞检测。请记住，球可以在一个部分的边界上与其他球碰撞，所以这可能会使您的代码更加复杂。不过，在你有几百个球之前，效率可能并不重要。为了获得额外的奖励，你可以在不同的核心上运行每个部分，或者在每个部分中拆分碰撞处理。
