Problème avec mon view frustum culling

Bonjour,

J'ai implémenté un view frustum culling, seulement voila mon implémentation s'avère un poil trop "efficace", à avoir qu'elle fait disparaitre des choses dans le champ de caméra :aie: J'ai remarqué que le view frustum fonctionne correctement uniquement lorsque le point (0,0,0) est visible dans le champ de camera. Mais impossible de trouver ce qui cause ce comportement. Voila mon code pour extraire les plans (juste une adaptation de ce tutoriel :

Code:

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
 
// Get the current PROJECTION matrix from OpenGL
        glGetFloatv( GL_PROJECTION_MATRIX, proj );
 
        // Get the current MODELVIEW matrix from OpenGL
        glGetFloatv( GL_MODELVIEW_MATRIX, modl );
 
        // Combine the two matrices (multiply projection by modelview)
        clip[ 0] = modl[ 0] * proj[ 0] + modl[ 1] * proj[ 4] + modl[ 2] * proj[ 8] + modl[ 3] * proj[12];
        clip[ 1] = modl[ 0] * proj[ 1] + modl[ 1] * proj[ 5] + modl[ 2] * proj[ 9] + modl[ 3] * proj[13];
        clip[ 2] = modl[ 0] * proj[ 2] + modl[ 1] * proj[ 6] + modl[ 2] * proj[10] + modl[ 3] * proj[14];
        clip[ 3] = modl[ 0] * proj[ 3] + modl[ 1] * proj[ 7] + modl[ 2] * proj[11] + modl[ 3] * proj[15];
 
        clip[ 4] = modl[ 4] * proj[ 0] + modl[ 5] * proj[ 4] + modl[ 6] * proj[ 8] + modl[ 7] * proj[12];
        clip[ 5] = modl[ 4] * proj[ 1] + modl[ 5] * proj[ 5] + modl[ 6] * proj[ 9] + modl[ 7] * proj[13];
        clip[ 6] = modl[ 4] * proj[ 2] + modl[ 5] * proj[ 6] + modl[ 6] * proj[10] + modl[ 7] * proj[14];
        clip[ 7] = modl[ 4] * proj[ 3] + modl[ 5] * proj[ 7] + modl[ 6] * proj[11] + modl[ 7] * proj[15];
 
        clip[ 8] = modl[ 8] * proj[ 0] + modl[ 9] * proj[ 4] + modl[10] * proj[ 8] + modl[11] * proj[12];
        clip[ 9] = modl[ 8] * proj[ 1] + modl[ 9] * proj[ 5] + modl[10] * proj[ 9] + modl[11] * proj[13];
        clip[10] = modl[ 8] * proj[ 2] + modl[ 9] * proj[ 6] + modl[10] * proj[10] + modl[11] * proj[14];
        clip[11] = modl[ 8] * proj[ 3] + modl[ 9] * proj[ 7] + modl[10] * proj[11] + modl[11] * proj[15];
 
        clip[12] = modl[12] * proj[ 0] + modl[13] * proj[ 4] + modl[14] * proj[ 8] + modl[15] * proj[12];
        clip[13] = modl[12] * proj[ 1] + modl[13] * proj[ 5] + modl[14] * proj[ 9] + modl[15] * proj[13];
        clip[14] = modl[12] * proj[ 2] + modl[13] * proj[ 6] + modl[14] * proj[10] + modl[15] * proj[14];
        clip[15] = modl[12] * proj[ 3] + modl[13] * proj[ 7] + modl[14] * proj[11] + modl[15] * proj[15];
 
 
        // Extract the numbers for the RIGHT plane
        frustum[0].X = clip[ 3] - clip[ 0];
        frustum[0].Y = clip[ 7] - clip[ 4];
        frustum[0].Z = clip[11] - clip[ 8];
        frustum[0].W = clip[15] - clip[12];
 
        // Extract the numbers for the LEFT plane
        frustum[1].X = clip[ 3] + clip[ 0];
        frustum[1].Y = clip[ 7] + clip[ 4];
        frustum[1].Z = clip[11] + clip[ 8];
        frustum[1].W = clip[15] + clip[12];
 
        // Extract the BOTTOM plane
        frustum[2].X = clip[ 3] + clip[ 1];
        frustum[2].Y = clip[ 7] + clip[ 5];
        frustum[2].Z = clip[11] + clip[ 9];
        frustum[2].W = clip[15] + clip[13];
 
        // Extract the TOP plane
        frustum[3].X = clip[ 3] - clip[ 1];
        frustum[3].Y = clip[ 7] - clip[ 5];
        frustum[3].Z = clip[11] - clip[ 9];
        frustum[3].W = clip[15] - clip[13];
 
        // Extract the FAR plane
        frustum[4].X = clip[ 3] - clip[ 2];
        frustum[4].Y = clip[ 7] - clip[ 6];
        frustum[4].Z = clip[11] - clip[10];
        frustum[4].W = clip[15] - clip[14];
 
        // Extract the NEAR plane
        frustum[5].X = clip[ 3] + clip[ 2];
        frustum[5].Y = clip[ 7] + clip[ 6];
        frustum[5].Z = clip[11] + clip[10];
        frustum[5].W = clip[15] + clip[14];
 
        for(int i(0) ; i < 6 ; ++i)
        {
            t = sqrt(frustum[i].X * frustum[i].X + frustum[i].Y * frustum[i].Y + frustum[i].Z * frustum[i].Z);
            frustum[i].X /= t;
            frustum[i].Y /= t;
            frustum[i].Z /= t;
        }

Ma méthode pour tester les points :

Code:

1
2
3
4
5
6
7
8
9
10
 
bool ViewFrustum::TestPointInFrustum(Vector3<float> p)
{
 
    for(int i(0) ; i < 6 ; ++i)
        if(frustum[i].X * p.X + frustum[i].Y * p.Y + frustum[i].Z * p.Z + frustum[i].W <= 0 )
            return false;
 
    return true;
}

La verticale de la scène est définie selon z.

Code:

1
2
 
gluLookAt(position.X,position.Y,position.Z,target.X,target.Y,target.Z,0,0,1);

Si la façon dont j'ai exposée mon problème n'est pas assez claire, je posterai une vidéo.

Merci par avance ;)