Discussion :

[Invité]

Bonsoir,

J'essaie actuellement de calculer les normales au sommets et apparemment je rencontre un soucis de normales discontinues ? ( pas sur que ce soit 100% le problème ) .

Voici le résultat. On peut observer certaines espaces plus ou moins flous


Voici l'algo que j'utilise :

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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
int num=0;
 
for(int z=0; z<nb_pt_z; z++ )
{
    for(int x=0; x<nb_pt_x; x++ )
    {
        Vector N(0.0, 0.0, 0.0);
 
        if (z != 0)
        {
            if (x != 0)
            {
 
                /* TRIANGLE N°1 DU SCHEMA */
                Vector P01(points_terrain[num-nb_pt_x].x - points_terrain[num].x,
                           points_terrain[num-nb_pt_x].hauteur - points_terrain[num].hauteur,
                           points_terrain[num-nb_pt_x].z - points_terrain[num].z);
 
                Vector P02(points_terrain[num-1].x - points_terrain[num].x,
                           points_terrain[num-1].hauteur - points_terrain[num].hauteur,
                           points_terrain[num-1].z - points_terrain[num].z);
 
 
                N += P01^P02;
            }
            if(x != nb_pt_x-1)
            {
 
                 /* TRIANGLE N°2 DU SCHEMA */
                Vector P01(points_terrain[num-(nb_pt_x+1)].x - points_terrain[num].x,
                           points_terrain[num-(nb_pt_x+1)].hauteur - points_terrain[num].hauteur,
                           points_terrain[num-(nb_pt_x+1)].z - points_terrain[num].z);
 
                Vector P02(points_terrain[num-nb_pt_x].x - points_terrain[num].x,
                           points_terrain[num-nb_pt_x].hauteur - points_terrain[num].hauteur,
                           points_terrain[num-nb_pt_x].z - points_terrain[num].z);
 
 
 
                N += P02 ^ P01;
 
 
                 /* TRIANGLE N°3 DU SCHEMA */
                Vector P03(points_terrain[num-(nb_pt_x+1)].x - points_terrain[num].x,
                           points_terrain[num-(nb_pt_x+1)].hauteur - points_terrain[num].hauteur,
                           points_terrain[num-(nb_pt_x+1)].z - points_terrain[num].z);
 
                Vector P04(points_terrain[num+1].x - points_terrain[num].x,
                           points_terrain[num+1].hauteur - points_terrain[num].hauteur,
                           points_terrain[num+1].z - points_terrain[num].z);
 
                N += P04 ^ P03;
            }
 
        }
 
        if(z != nb_pt_z)
        {
 
            if(x != nb_pt_x-1)
            {
 
                /* TRIANGLE N°4 DU SCHEMA */
                Vector P01(points_terrain[num+nb_pt_x].x - points_terrain[num].x,
                           points_terrain[num+nb_pt_x].hauteur - points_terrain[num].hauteur,
                           points_terrain[num+nb_pt_x].z - points_terrain[num].z);
 
                Vector P02(points_terrain[num+1].x - points_terrain[num].x,
                           points_terrain[num+1].hauteur - points_terrain[num].hauteur,
                           points_terrain[num+1].z - points_terrain[num].z);
 
                N += P01^ P02;
 
            }
 
            if(x != 0)
            {
                /* TRIANGLE N°5 DU SCHEMA */
                Vector P01(points_terrain[num+(nb_pt_x-1)].x - points_terrain[num].x,
                           points_terrain[num+(nb_pt_x-1)].hauteur - points_terrain[num].hauteur,
                           points_terrain[num+(nb_pt_x-1)].z - points_terrain[num].z);
 
                Vector P02(points_terrain[num+nb_pt_x].x - points_terrain[num].x,
                           points_terrain[num+nb_pt_x].hauteur - points_terrain[num].hauteur,
                           points_terrain[num+nb_pt_x].z - points_terrain[num].z);
 
 
                N += P01 ^P02;
 
                /* TRIANGLE N°6 DU SCHEMA */
                Vector P03(points_terrain[num-1].x - points_terrain[num].x,
                           points_terrain[num-1].hauteur - points_terrain[num].hauteur,
                           points_terrain[num-1].z - points_terrain[num].z);
 
                Vector P04(points_terrain[num+(nb_pt_x-1)].x - points_terrain[num].x,
                           points_terrain[num+(nb_pt_x-1)].hauteur - points_terrain[num].hauteur,
                           points_terrain[num+(nb_pt_x-1)].z - points_terrain[num].z);
 
 
                N += P04 ^P03;
            }
 
        }
 
        N.normalize();
        points_terrain[num].nx =N.x;
        points_terrain[num].ny =N.y;
        points_terrain[num].nz =N.z;
        num++;
    }
 
---------
typedef struct                                  
{
    GLfloat s, t;
    GLfloat nx, ny, nz;
    GLfloat x, hauteur,z;                               
 
} Point_terrain; /*points_terrain est donc un pointeur de Point_terrain *

Je m'appuie sur ce schéma pour mon algo :


Quelqu'un saurait d'ou pourrait venir ce problème ?

J'ai fais et refais puis -re-refait l'algo à la main et testé, normalement cela doit être bon ..

[LittleWhite]

Bonjour,

Peut être vous vous décalez d'un triangle (et donc, vous ne prenez pas le bon).
Sinon, je normaliserai chaque variable, mais je doute que cela change vraiment quoique ce soit.

[Invité]

Décalage d'un triangle, c'est à dire ?

[LittleWhite]

Dans le sens, au lieu de prendre les six triangles adjacents, vous prenez un qui n'est pas adjacent, mais sincèrement je doute, mais il faut mieux vérifier.
De plus, pour des raisons de déboguage, essayez d'avoir un terrain plus petit

[Invité]

D'accord, pour la vérification des triangles autour, cela doit être normalement bon ..

Par contre j'utilise des Vertex Array pour les dessiner, si jamais quelqu'un aurait une illumination