球与球的碰撞（C++）

Question

我正在实现一些基础的三维物理引擎。对于球与球之间的碰撞，我遵循这个教程。我在处理两个移动中的球时遇到了问题。我想可能是我找到“缩短速度”的方式有问题。

bool collidingDSmove(Sphere sphere){
    // Early Escape test: if the length of the movevec is less
    // than distance between the centers of these circles minus 
    // their radii, there's no way they can hit.

在我的测试场景中，速度向量分别为(-2,-4,-2)和(1,2,1)。因此，“shortVel”实际上比原始速度更大。

    vec3 shortVel = sphere.velocity.substract(velocity);
    vec3 fromAtoBCenter = position.substract(sphere.position);
    float distSquare = fromAtoBCenter.getLengthSquare();
    float sumRadii = (radius + sphere.radius);
    distSquare -= sumRadii*sumRadii;
    if (shortVel.getLengthSquare() < distSquare){
        return false;
    }

    // Normalize the movevec
    vec3 N = shortVel.normalize();

    // Find C, the vector from the center of the moving 
    // circle A to the center of B
    vec3 C = sphere.position.substract(position);

    // D = N . C = ||C|| * cos(angle between N and C)
    float D = N.dot(C);

    // Another early escape: Make sure that A is moving 
    // towards B! If the dot product between the movevec and 
    // B.center - A.center is less that or equal to 0, 
    // A isn't isn't moving towards B
    if (D <= 0){
        return false;
    }
    // Find the length of the vector C
    float lengthCSquare = C.getLengthSquare();

    float F = (lengthCSquare)-(D * D);

    // Escape test: if the closest that A will get to B 
    // is more than the sum of their radii, there's no 
    // way they are going collide
    float sumRadiiSquared = sumRadii * sumRadii;
    if (F >= sumRadiiSquared){
        return false;
    }

    // We now have F and sumRadii, two sides of a right triangle. 
    // Use these to find the third side, sqrt(T)
    double T = sumRadiiSquared - F;

    // If there is no such right triangle with sides length of 
    // sumRadii and sqrt(f), T will probably be less than 0. 
    // Better to check now than perform a square root of a 
    // negative number. 
    if (T < 0){
        return false;
    }

    // Therefore the distance the circle has to travel along 
    // movevec is D - sqrt(T)
    float distance = D - sqrt(T);

    // Get the magnitude of the movement vector
    float mag = velocity.getLength();

    // Finally, make sure that the distance A has to move 
    // to touch B is not greater than the magnitude of the 
    // movement vector. 
    if (mag < distance){
        return false;
    }

//*** 数量不在0和1之间

    float amount = shortVel.normalize().getLength() / velocity.getLength();
    // Set the length of the movevec so that the circles will just 
    // touch
    velocity = velocity.normalize().times(amount);
    sphere.velocity = sphere.velocity.normalize().times(amount);

    return true;
}

我的vec3类如下：

class vec3 {
public:
    float x; float y; float z;
    vec3() : x(0), y(0), z(0) { }
    vec3 substract(vec3 v){
        vec3 sub;
        sub.x = x - v.x;
        sub.y = y - v.y;
        sub.z = z - v.z;
        return sub;
    }
float getLength() {
        return sqrt(x*x + y*y + z*z);
    }
float getLengthSquare() {
        return x*x + y*y + z*z;
    }
vec3 normalize(){
        vec3 n;
        n.x = x / getLength();
        n.y = y / getLength();
        n.z = z / getLength();
        return n;
    }
float dot(vec3 v) {
        return x*v.x + y*v.y + z*v.z;
    }
}

请问我在这里做错了什么？

以下是我的更新函数。其中deltaT是两帧之间经过的时间

void updateVelocity(double deltaT){
        velocity.x = velocity.x + acceleration.x*deltaT;
        velocity.y = velocity.y + acceleration.y*deltaT;
        velocity.z = velocity.z + acceleration.z*deltaT;
    }
    void updatePosition(double deltaT){
        position.x = position.x + velocity.x * deltaT + 0.5 * acceleration.x * deltaT * deltaT;
        position.y = position.y + velocity.y * deltaT + 0.5 * acceleration.y * deltaT * deltaT;
        position.z = position.z + velocity.z * deltaT + 0.5 * acceleration.z * deltaT * deltaT;
    }
    void update(double deltaT){
        updateVelocity(deltaT);
        updatePosition(deltaT);

    }

- Inventor

---

没错。我添加了这个normalize()步骤来尝试修复代码。教程的作者没有提到规范化步骤。引用：如果它们碰撞了，将缩短向量的长度除以最初传递到函数中的向量的长度。结果应该是0到1之间的浮点数。这表示在它们的运动过程中圆形发生碰撞的时间。将原始运动向量乘以此数字。 - Inventor

你做的一件事是忽略了对这个规模的项目进行适当的维护。你应该知道，要么 vec3 有问题，要么完全跳过它。特别是，你没有为已完成的模块编写单元测试。此外，为什么不拿起铅笔和信封，逐步检查你的算法，看看是否一切都像应该的那样工作？不幸的是，这个问题也超出了话题范围，因为你询问代码有什么问题，但没有提供最小示例或任何预期的输入输出。 - luk32

@molbdnilo 嗯...我不太确定你的意思。现在我会添加我的更新函数代码。 - Inventor

那么，没有对shortVel进行归一化的代码行float amount = shortVel.getLength() / velocity.getLength();给出了大于1的值？更新是顺序的还是您正在使用多线程或其他形式的并行处理？ - Pedrom

@Inventor 作者一贯使用“运动向量”这个术语。它不是速度，而是如果物体没有与任何东西碰撞，它将在时间步长中行进的“路径”。 - molbdnilo

Answer 1

首先，在vec3中创建加和乘函数。

如果一个位置为p（vec3），速度为v（vec3），半径为r（float）和质量为m（float）的球体s1和球体s2相撞了，可以这样做：

// from s1 to s2
vec3 pDiff = s2.p.subtract(s1.p);
// collision detection
if (pDiff.getLength() >= s1.r + s2.r) {
    return;
}
// find direction from s1 to s2
vec3 dir = pDiff.normalize();
vec3 vDiff = s2.v.subtract(s1.v);
float fellingSpeed = vDiff.dot(dir);
// don't collide in this case
if (fellingSpeed >= 0) {
    return;
}
// perfect spheric collision
float speed1 = (2 * s2.m * fellingSpeed) / (s1.m + s2.m);
float speed2 = (fellingSpeed * (s2.m - s1.m)) / (s1.m + s2.m);
s1.v = s1.v.add(dir.times(speed1));
s2.v = s2.v.add(dir.times(speed2 - fellingSpeed));

希望对您有所帮助。

- Nicolas Mafra