Bonjour,

je cherche à modéliser une sphère en 3D par triangulation mais j'ai quelques problèmes d'algo. Je travaille en langage C avec la librairie d'OpenGL.

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
struct StructSphere {
 
  int _nbTriangles; // nombre de triangles à modéliser
 
  GLfloat (*vertices)[3]; // tableau de sommets : l'indice du tableau est le numéro du sommet. Pour chaque sommet on stocke ses coordonnées x, y et z.  
  GLint (*triangles)[3]; // d'un tableau de triangles : l'indice du tableau est le numéro du triangle. Pour chaque triangle on stocke les indices de ses trois sommets 
  GLfloat (*normalsT)[3]; // d'un tableau de normales : dans la version simple on a autant de normales que de triangles. Ces normales sont les vecteurs normaux à chaque triangle. 
};
L'algo trace des disques superposés en modifiant juste le rayon mais je pense que ce n'est pas le meilleur


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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
/*--- Sphere ---*/
 
void initSphere (Sphere * sphere , int nvertices)
{
  int i;                 
  int j;                 
  int nbT;               
  nbT=0;                 
  int nbD;               
  int nbV;               
  float r;               
  r = RAYON;
  float rapport;
  float aux; 
  aux = (nvertices/2) +1;
  int i_sauv;            
  rapport = 1 / aux;
  float h;               
  h = 0;
 
  int disk;              
  disk = 0;
 
  int nv;
  nv = ( (nvertices+1) * nvertices) + 2;
 
 // initialisation _nbTriangles  wether nvertices is PAIR or IMPAIR
  if ( (nvertices %2) == 0) sphere->_nbTriangles = (2*nvertices + 2) * nvertices;
  else sphere->_nbTriangles = 2 * nvertices * nvertices;
 
// allocation dynamiqe
  sphere->vertices = malloc(nv * sizeof (*sphere->vertices));
  sphere->triangles = malloc(sphere->_nbTriangles * sizeof (*sphere->triangles));
  sphere->normalsT = malloc(sphere->_nbTriangles * sizeof (*sphere->normalsT));
 
// calcul de l'angle
  float teta = (2 * M_PI) /nvertices;
 
 
   // premier disque du milieu
   for (i=0; i<nvertices; i++) {
    sphere->vertices[i][0] = r * cos(i*teta);
    sphere->vertices[i][1] = r * sin(i*teta);
    sphere->vertices[i][2]  = 0;                      
 
}
 
  // les autres disques
   for( nbD=1; nbD<nvertices; nbD=nbD+2) {
      h = h + rapport; // calcul pour diminuer la hauteur de chaque disque
      r = r - (RAYON*rapport); // calcul pour diminuer le rayon de chaque disque
 
     for( i=0; i<nvertices; i++) {
       sphere->vertices[(nbD*nvertices)+i][0] = r * cos(i*teta);
       sphere->vertices[(nbD*+nvertices)+i][1] = r * sin(i*teta);
       sphere->vertices[(nbD*nvertices)+i][2]  = h;                         
 
       sphere->vertices[( (nbD+1)*nvertices) +i][0] = r * cos(i*teta);
       sphere->vertices[( (nbD+1)*nvertices) +i][1] = r * sin(i*teta);
       sphere->vertices[( (nbD+1)*nvertices) +i][2]  = -h; 
 
     }
   }
 
   // dernier triangle du haut
   sphere->vertices[nbD*nvertices][0] = 0;
   sphere->vertices[nbD*nvertices][1] = 0;
   sphere->vertices[nbD*nvertices][2]  = RAYON;   
 
   // dernier triangle du bas
   sphere->vertices[(nbD*nvertices)+1][0] = 0;
   sphere->vertices[(nbD*nvertices)+1][1] = 0;
   sphere->vertices[(nbD*nvertices)+1][2]  = -RAYON;     
 
 
   // triangulation
   for (nbD=0; nbD<nvertices; nbD++) {
 
     // premier disque
     if (nbD == 0) i_sauv = (nvertices-1) * nvertices;
     else { 
       if (disk) { i_sauv = 0;  disk = 0;  }
       else i_sauv = abs(i_sauv - 2*nvertices);
     }
 
 
     for(nbV=0; nbV<nvertices-1; nbV++) {
       i = i_sauv + nbV;
 
       // cas du disk au dessus du centre
       j = i - 2*nvertices;
 
       if ( j<0  && j>=-nvertices)  {
         j += nvertices; 
         disk = 1;
 
       }
       j = abs(j);
 
       sphere->triangles[nbT][0] = i;
       sphere->triangles[nbT][1] = j;
       sphere->triangles[nbT][2] = j + 1;
 
       sphere->triangles[nbT+1][0] = i;
       sphere->triangles[nbT+1][1] = j + 1;
       sphere->triangles[nbT+1][2] = i + 1;
 
       nbT += 2;
     }
 
 
      i = i + 1;
      j = i - 2*nvertices;
 
      if ( disk)  {
        j += nvertices; 
      }
 
      // les 2 derniers triangles d'un disque
      sphere->triangles[nbT][0] = i;
      sphere->triangles[nbT][1] = j;
      sphere->triangles[nbT][2] = j - nvertices + 1;
 
	  sphere->triangles[nbT+1][0] = i;
      sphere->triangles[nbT+1][1] = j - nvertices + 1;
      sphere->triangles[nbT+1][2] = i_sauv;
 
      nbT += 2;
     }
 
 
   // les triangles du haut
   for(nbV=0; nbV<nvertices; nbV++) {
     sphere->triangles[nbT][0] = nv-2;
     sphere->triangles[nbT][1] = ( (nvertices-1) * nvertices) + 1 + nbV;
     sphere->triangles[nbT][2] = ( (nvertices-1) * nvertices) + nbV;
      nbT++;
   }
 
  // les triangles du bas
   for(nbV=0; nbV<nvertices; nbV++) {
     sphere->triangles[nbT][0] = nv-1;
     sphere->triangles[nbT][1] = nvertices * nvertices + nbV;
     sphere->triangles[nbT][2] = nvertices * nvertices + 1 + nbV;
 
   nbT++;
   }
 
}
J'ai trouvé sinon l'équation paramétrique d'un sphère mais je ne sais pas comment l'utiliser
x = R cos u cos v
y = R cos u sin v
z = R sin u

peut etre que les paramètres passés à la fonction init ne sont pas bien choisis