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