Por que os objetos interpenetram neste solucionador de colisões simples?

O código abaixo é de um exemplo do Microsoft XNA aqui . Essa é uma simulação bastante simples do corpo rígido que ignora muitos efeitos físicos (como o momento angular), mas tenta separar objetos (esferas) para que eles não se penetrem.

No entanto, a simulação permite que as esferas não apenas penetrem, mas quando muitas esferas são empilhadas umas sobre as outras, pequenas esferas podem estar quase completamente dentro de esferas maiores. Se eu fizer todas as esferas com o mesmo raio e massa, a simulação terá um desempenho razoavelmente bom (com interpenetração mínima).

Alguém pode explicar por que existe alguma interpenetração? Uma vez que move as posições das esferas, parece que a interpenetração deve ser impossível.

Para cada esfera na simulação, esse método é chamado em todas as outras esferas.

/// <summary>
// Given 2 spheres with velocity, mass and size, evaluate whether
// a collision occured, and if so, excatly where, and move sphere 2
// at the contact point with sphere 1, and generate new velocities.
/// </summary>
private void SphereCollisionImplicit(Sphere sphere1, Sphere sphere2)
{
    const float K_ELASTIC = 0.75f;

    Vector3 relativepos = sphere2.Position - sphere1.Position;
    float distance = relativepos.Length();
    float radii = sphere1.Radius + sphere2.Radius;
    if (distance >= radii)
    {
        return; // No collision
    }

    // Add epsilon to avoid NaN.
    distance += 0.000001f;

    Vector3 relativeUnit = relativepos * (1.0f / distance);
    Vector3 penetration = relativeUnit * (radii - distance);

    // Adjust the spheres' relative positions
    float mass1 = sphere1.Mass;
    float mass2 = sphere2.Mass;

    float m_inv = 1.0f / (mass1 + mass2);
    float weight1 = mass1 * m_inv; // relative weight of sphere 1
    float weight2 = mass2 * m_inv; // relative weight of sphere 2. w1+w2==1.0

    sphere1.Position -= weight2 * penetration;
    sphere2.Position += weight1 * penetration;

    // Adjust the objects’ relative velocities, if they are
    // moving toward each other.
    //
    // Note that we're assuming no friction, or equivalently, no angular momentum.
    //
    // velocityTotal = velocity of v2 in v1 stationary ref. frame
    // get reference frame of common center of mass
    Vector3 velocity1 = sphere1.Velocity;
    Vector3 velocity2 = sphere2.Velocity;

    Vector3 velocityTotal = velocity1 * weight1 + velocity2 * weight2;
    Vector3 i2 = (velocity2 - velocityTotal) * mass2;
    if (Vector3.Dot(i2, relativeUnit) < 0)
    {
        // i1+i2 == 0, approx
        Vector3 di = Vector3.Dot(i2, relativeUnit) * relativeUnit;
        i2 -= di * (K_ELASTIC + 1);
        sphere1.Velocity = (-i2) / mass1 + velocityTotal;
        sphere2.Velocity = i2 / mass2 + velocityTotal;
    }
}

Em particular, eu acho que isso:

sphere1.Position -= weight2 * penetration;
sphere2.Position += weight1 * penetration;

Deve proibir completamente qualquer interpenetração, por que não?

Acho que seu problema vem de várias colisões.

Considere três esferas A, B e C.

A fica lá.

B bate A. Bem.

C atinge B. B é empurrado para A. Opa.

Este código está pegando a colisão entre duas esferas e movendo-as com base em suas massas e velocidade.

Aqui está uma ilustração realmente básica para mostrar por que há penetração entre uma bola azul e uma parede verde.

Neste exemplo, o centro da bola fica a 1,5 metro da borda da parede. A bola está se movendo a 1 pé por segundo e você está correndo com uma taxa de quadros de 1 quadro por segundo. No quadro 4 não há penetração, mas o quadro 5 terá penetração. Não há como saber que o quadro 5 colidirá, então você não pode simplesmente dizer parar quando ele chegar à parede. Em vez disso, verifique cada quadro se a bola estiver parcialmente dentro da parede. Se estiver, mova-o de volta pela quantidade de penetração e aplique a velocidade reflexiva. É assim que a maioria dos algoritmos de detecção de colisão funciona. A alternativa é verificar cada quadro a que distância você está colidindo em uma determinada direção. O problema é que você precisa saber qual direção verificar. Isso não funcionaria na sua situação, portanto o caminho que você está seguindo é o caminho certo.

A desvantagem dessa abordagem é o nervosismo que você provavelmente está enfrentando. Quando esse script instrui uma bola a se mover com base na última colisão, ela pode estar se movendo para penetrar em outra bola, o que fará com que a bola volte a colidir com a primeira. Fazendo-o pular para frente e para trás. Você pode modificar a massa dos objetos para ajudar nisso. Isso fará com que eles recuem um pouco menos drasticamente ou reduzam a velocidade com que colidem.

Você deve ler sobre contatos especulativos para quando ocorrerão colisões antes de acabar com esse tipo de penetração.

SphereCollisionImplicit () é chamado depois que as esferas foram movidas. Esse movimento poderia ter acabado com colisão e interpenetração, esse método resolve isso.

quadro inicial:

1. em outro lugar no seu código, a posição é atualizada pela velocidade.

2. Então, esse método é chamado para verificar se isso resultou em colisão / penetração.

3. Nesse caso, ele os separa e reflete / altera suas velocidades.

4. No próximo quadro, as posições são atualizadas com velocidade nova / alterada ... goto 1.

Existe interpenetração porque, toda vez que a posição e a velocidade de uma bola são alteradas, ela precisa ser verificada para verificar se colidiu com outra bola que foi verificada anteriormente no loop. Por exemplo, dadas 3 bolas:

Partida 1. A bola # A é checada contra a bola #B, sem colisão

1. A bola # A é checada contra a bola # C, sem colisão

2. A bola # B é verificada contra a bola # A, sem colisão

3. A bola # B é verificada contra a bola # C, encontrou colisão !! A bola # B e # C são movidas.

4. A bola # C é marcada contra a bola # A, sem colisão

5. A bola # C é verificada contra a bola # B, sem colisão

Feito

Então ... A Etapa 2 pode ter movido a Bola # B para a Bola # A, causando interpenetração.

Para consertar, acho que sempre que uma bola é movida, ela precisa ser verificada novamente com todas as outras bolas, sempre que for movida. Nesse cenário, a bola # B esbarra na bola # C, a bola richocheting # B na bola # A, a bola richocheting # A na bola # C !, que atinge a bola # B novamente ....

Quantos richochets você processa em um quadro? Você também precisa verificar novamente todas as paredes após cada richochet?

Partida 1. A bola # A é checada contra a bola #B, sem colisão

1. A bola # A é checada contra a bola # C, sem colisão

2. A bola # B é verificada contra a bola # A, sem colisão

3. A bola # B é verificada contra a bola # C, encontrou colisão !! A bola # B e # C são movidas.

4. Reinicie o loop #B e #C ...

5. A bola # B é verificada contra a bola # A, encontrou uma colisão !! A bola #B e #A são movidas

6. Reinicie o loop #B e #A ...

7. A bola # A é checada contra a bola #B, sem colisão

8. A bola # A é verificada contra a bola # C, colisão encontrada !! A bola # A e #C são movidas

9. Reinicie o loop #A e #C

10. A bola # A é checada contra a bola #B, sem colisão

11. A bola # A é checada contra a bola # C, sem colisão

12. A bola # B é verificada contra a bola # A, sem colisão

13. A bola # B é verificada contra a bola # C, encontrou colisão !! A bola #B e #C são movidas

14. Reinicie o loop #B e #C

15. A bola # B é verificada contra a bola # A, sem colisão

16. A bola # B é marcada contra a bola # C, sem colisão

17. A bola # C é marcada contra a bola # A, sem colisão

18. A bola # C é marcada contra a bola # B, sem colisão Concluída