Bücher zur Kollisionserkennung

[joomoo]

Ich hatte vor einem halben Jahr mal folgenden Thread gestartet: http://www.c-plusplus.net/forum/viewtopic-var-t-is-124214.html
TGGC hatte da eine Möglichkeit gepostet wie man das löst, und zwar mit einer dritten Dimension, der Zeit. Nur wie lässt sich eine Schnittpunktserkennung für 3D-Objekte (z.B. schräger Zylinder für bewegenden Kreis) realisieren? Ich hab davon absolut keine Ahung und wollte mal fragen was es für Bücher dazu gibt, die erstmal nur das mathematische beschreiben, am besten auf Deutsch.
Hab schon gegoogelt und dabei den Begriff "dynamische Kollisionserkennung" gefunden. Ist es das was ich suche?

mfg.

[ChaosAngel]

http://www.peroxide.dk/papers/collision/collision.pdf

[Vertex]

http://www.scherfgen-software.net/index.php?action=tutorials
http://www.geometrictools.com/Documentation.html

[joomoo]

Vielen Dank für die Links! Der von Scherfgen hat mir sehr geholfen und nun habe ich das mit den Zylindern gemacht:

bool CircleHitsCircle(const Vector2d& A, const double radiusA,
                      const Vector2d& B, const double radiusB)
{
    return (A - B).LengthSq() < (radiusA + radiusB) * (radiusA + radiusB);
}

bool CylinderHitsCylinder(const Vector2d& startA,
                          const Vector2d& endA,
                          const double radiusA,
                          const Vector2d& startB,
                          const Vector2d& endB,
                          const double radiusB,
                          const double height,
                          double* const pOut)
{
    if(CircleHitsCircle(startA, radiusA, startB, radiusB))
    {
        if(pOut)
        {
            *pOut = 0;
        }
        return true;
    }

    const Vector3d directionA((endA.X() - startA.X()) / height,
                              (endA.Y() - startA.Y()) / height,
                              1);

    const Vector3d directionB((endB.X() - startB.X()) / height,
                              (endB.Y() - startB.Y()) / height,
                              1);

    const double a = (directionA - directionB).LengthSq();

    const double b = 2 * (directionB.Y() * startB.Y() -
                          directionA.Y() * startB.Y() +
                          directionB.X() * startB.X() -
                          directionA.X() * startB.X() -
                          directionB.Y() * startA.Y() +
                          directionA.Y() * startA.Y() -
                          directionB.X() * startA.X() +
                          directionA.X() * startA.X());

    const double c = (startA - startB).LengthSq() -
                     (radiusA + radiusB) * (radiusA + radiusB);

    const double dis = b*b - 4*a*c;

    if(dis < 0)
    {
        return false;
    }

    const double h = (-b - sqrt(dis)) / (2 * a);

    if(h < 0 || h > height)
    {
        return false;
    }

    if(pOut)
    {
        *pOut = h;
    }

    return true;
}

Ist das so in Ordnung oder könnte man das noch optimieren?

Naja, mein Problem ist: Sobald ich jetzt keine lineare Bewegung mehr habe (was bei nem Spiel ja eigentlich immer der Fall ist), klappt das ganze nicht mehr. Was kann man da machen? Und was wenn nun eine Explosion hineinkommt, und der Pfad der Kreise kaum noch als Formel darzustellen ist?

mfg.