Discussion :

[sylvain_bos]

Bonjour

je cherche un algo( ou un code C++) de détection de collisions entre sphère et une OBB (Oriented Bounding Box).

bien entendu, j'ai regardé la FAQ mais, sauf erreur de ma part, je n'ai pas trouvé d'algo correspondant.

merci.

[Laurent Gomila]

Salut

Tu n'as pas trouvé ton bonheur parmi ces liens cités dans la FAQ ?

http://jeux.developpez.com/faq/3d/?p...TERSECTIONS_ou

[Laurent Gomila]

Par exemple :

http://www.geometrictools.com/Intersection.html

-> "Intersection of boxes and spheres (3D)"

[sylvain_bos]

merci beaucoup loulou24.
maintenant je vais essayer de comprendre le code .

[sylvain_bos]

je viens de jeter un oeil au code ci-dessous:
et j'ai quelques questions a propos des données menbres de class box.

m_rkBox.Axis[0] represente la direction de l'axe X (après rotation) de la boite ? normalisé ?
m_rkBox.Axis[2] represente la direction de l'axe Y (après rotation) de la boite ? normalisé ?
et pareil pour Z

m_rkBox.Extend[0] represente la dimension de la boite sur l'axe X? ou bien la distance du centre l'extremité de la boite ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
bool IntrBox3Sphere3<Real>::Test ()
{
    // Test for intersection in the coordinate system of the box by
    // transforming the sphere into that coordinate system.
    Vector3<Real> kCDiff = m_rkSphere.Center - m_rkBox.Center;
 
    Real fAx = Math<Real>::FAbs(kCDiff.Dot(m_rkBox.Axis[0]));
    Real fAy = Math<Real>::FAbs(kCDiff.Dot(m_rkBox.Axis[1]));
    Real fAz = Math<Real>::FAbs(kCDiff.Dot(m_rkBox.Axis[2]));
    Real fDx = fAx - m_rkBox.Extent[0];
    Real fDy = fAy - m_rkBox.Extent[1];
    Real fDz = fAz - m_rkBox.Extent[2];
 
    if (fAx <= m_rkBox.Extent[0])
    {
        if (fAy <= m_rkBox.Extent[1])
        {
            if (fAz <= m_rkBox.Extent[2])
            {
                // sphere center inside box
                return true;
            }
            else
            {
                // potential sphere-face intersection with face z
                return fDz <= m_rkSphere.Radius;
            }
        }
        else
        {
            if (fAz <= m_rkBox.Extent[2])
            {
                // potential sphere-face intersection with face y
                return fDy <= m_rkSphere.Radius;
            }
            else
            {
                // potential sphere-edge intersection with edge formed
                // by faces y and z
                Real fRSqr = m_rkSphere.Radius*m_rkSphere.Radius;
                return fDy*fDy + fDz*fDz <= fRSqr;
            }
        }
    }
    else
    {
        if (fAy <= m_rkBox.Extent[1])
        {
            if (fAz <= m_rkBox.Extent[2])
            {
                // potential sphere-face intersection with face x
                return fDx <= m_rkSphere.Radius;
            }
            else
            {
                // potential sphere-edge intersection with edge formed
                // by faces x and z
                Real fRSqr = m_rkSphere.Radius*m_rkSphere.Radius;
                return fDx*fDx + fDz*fDz <= fRSqr;
            }
        }
        else
        {
            if (fAz <= m_rkBox.Extent[2])
            {
                // potential sphere-edge intersection with edge formed
                // by faces x and y
                Real fRSqr = m_rkSphere.Radius*m_rkSphere.Radius;
                return fDx*fDx + fDy*fDy <= fRSqr;
            }
            else
            {
                // potential sphere-vertex intersection at corner formed
                // by faces x,y,z
                Real fRSqr = m_rkSphere.Radius*m_rkSphere.Radius;
                return fDx*fDx + fDy*fDy + fDz*fDz <= fRSqr;
            }
        }
    }
}

[Laurent Gomila]

m_rkBox.Axis[0] represente la direction de l'axe X (après rotation) de la boite ? normalisé ?
m_rkBox.Axis[2] represente la direction de l'axe Y (après rotation) de la boite ? normalisé ?

Il s'agit des axes, oui, et certainement normalisés vu qu'on s'en sert ensuite pour calculer des distances via des produits scalaires.

m_rkBox.Extend[0] represente la dimension de la boite sur l'axe X? ou bien la distance du centre l'extremité de la boite ?

Je dirais qu'il s'agit de la distance du centre à l'extrémité, vu les tests qui suivent.

[sylvain_bos]

Citation:
m_rkBox.Axis[0] represente la direction de l'axe X (après rotation) de la boite ? normalisé ?
m_rkBox.Axis[2] represente la direction de l'axe Y (après rotation) de la boite ? normalisé ?

Il s'agit des axes, oui, et certainement normalisés vu qu'on s'en sert ensuite pour calculer des distances via des produits scalaires.

Donc ça marche bien, cependant il ne faut pas normaliser les vecteur m_rkBox.Axis[0], m_rkBox.Axis[1], m_rkBox.Axis[2].

maintenant je voudrais adapter cet algo pour un cylindre( toujours debout ) avec une OBB. Cependant je n'obtiens rien de concluant.
Alors si quelqu'un a une idée des modifs à apporter ou bien un lien pour un algo entre un cylindre (debout) et une OBB.

merci

[sylvain_bos]

j'ai fais quelques essais en modifiant cet algo.
j'ai pensé ( betement ) quand decomposant les calculs selon les axes ( X et Z d'un coté et Y de l'autre).

un petit exemple :
j'ai remplacé ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
float fRSqr = b->Rayon * b->Rayon;
return ((fDy * fDy + fDz * fDz) <= fRSqr);

par :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
if((fDz * fDz)<= (b->Rayon * b->Rayon))
{
      // sur l'axe Y
      if((fDy * fDy) <= (b->Hauteur * b->Hauteur))
           return true;
      else
           return false;
}
else
   return false;

et donc ça marche bien sur les axes X et Z ==> ce qui est logique.
mais je n'arrive a rien sur l'axe Y.
si quelqu'un aurait ue idée lumineuse