Discussion :

[overdrivr]

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 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 :

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
 
// 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 :

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

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 :

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

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

[LastSpear]

Bonsoir,

J'ai rapidement survolé, mais il n'y a pas assez d'information. Mais je pense pouvoir t'aider :
Ce qui me semble la meilleur façon de faire un frustum culing est en faite:

Au chargement, tu calcul les coordonné du centre de chaque objets (ou s'arranger pour que l'objet soit déjà centre en (0, 0, 0)), et la plus grande distance entre le sommet le plus éloigné et ce centre (que nous appelleront RayonObjet).

ensuite, pour chaque instances, tu calcul:
- DistanceCamera : la distance entre le plan de la camera, et la position de l'instance,
- DistanceCone : la distance minimal entre la droite définie par la position et la direction de la camera, et toujours la position de cette même instance.

En connaissant l'angle de projection de la camera (AngleCamera) tu en déduit la condition pour affiché ton instance :

Code :

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

1
2
3
 
if ( DistanceCone - (RayonObjet / cos(AngleCamera / 2.0)) < DistanceCamera * sin(AngleCamera / 2.0) )
      afficher ();

Pour optimisé encore plus, regarde aussi la doc sur les occlusions querys. sa te permet de compté le nombre de samples dessiné. Donc quand tu dessine du plus près au plus loin, tu peut savoir si une instance sera cacher même si elle se trouve dans le champ de la camera. Et donc tu peut prévoir pour un certain nombre de frams suivante si tu peut ne pas la dessiner. (en pensant quand même à le redessiner de temps en temps pour vérifié qu'il ne soit pas réapparu).