Discussion :

[erkoil]

Bonjour tout le monde.

Voilà en ce moment j'essais d'implémenter un algo de subdivisions, et je voudrais savoir s'il existe une fonction opengl pour obtenir, à partir d'un point, ceux auquel il est relié par un segment (j'utilise gl.h, glu.h et glut.h).

Ou alors si quelqu'un a une idée pour y arriver ?


merci

[Ti-R]

A ma connaissance non.

[bafman]

dans l'absolu : non
openGL ne conserve pas les information sur ce qu'il affiche, c'est pourquoi il faut lui réenvoyer a chaque affichage. En fait a chaque fois qu'il reçoit les trois points qui forment un triangle, il l'affiche et pui l'oublie...

[Finch]

Bonjour tout le monde.

Voilà en ce moment j'essais d'implémenter un algo de subdivisions, et je voudrais savoir s'il existe une fonction opengl pour obtenir, à partir d'un point, ceux auquel il est relié par un segment (j'utilise gl.h, glu.h et glut.h).

Je pense que le plus facile reste que tu definisses une structure de donnée, te donnant les voisins. Je ne vois en effet sinon aucun moyen pour "opengl", de savoir qui est son voisin.

[erkoil]

oki merci


sinon est-ce que quelqu'un aurait des infos à me donner concernant les algos de subdivision ? J'ai fait pas mal de recherche mais rien de très clair, en gros ils disent tous "on part de là, on divise, pis on arrive là", mais aucun ne détaille l'algo qui pourtant doit pas être monstrueux

[pascal_damien]

Salut,


Pour les subdivisions, tu peux turbiner quelque chose tout seul (ça dépend pas mal de la subdivision que tu veux faire) ou alors chercher du côté de butterfly, Catmull-Clark ...

Les algorithmes ne sont pas forcément monstrueux, mais ils se cachent assez bien.

[erkoil]

le genre de subdivisions que j'aimerais faire est assez simple, comme partir d'un tétraèdre et arriver à forme plus arrondie.

Ou alors faire ça :


J'ai déjà essayé de faire des recherches sur le modified butterfly mais pareil, je patauge, aucune vraie explication de l'algo ou alors ils le cachent derrière des formules balancées comme ça....

Pourtant il doit bien y avoir un algo plus simple !

[pascal_damien]

Salut,

J'ai bien un algo qui fait ça, je vais le chercher ...
Est-ce que même en pascal, du code te conviendrait ?

[erkoil]

ouaip ça me conviendrait parfaitement, du moment que je peux comprendre ce que tu fais dedans, je pourrai le transposer dans un autre langage, je connais pas mal pascal

merci

[pascal_damien]

Salut,


Je préfère te prévenir, mais le code est assez mastoc et peu commenté. Il y a également du code qui n'intervient pas dans la subdivision. Il y a deux types de subdivisions, le premier (~sphérique) considère que l'objet doit être arrondi et est centré lorsque la subdivision à lieu (ou plutôt centré en DivideOrigin ; sinon ça fonctionne, mais le résultat peut être étonnant), le deuxième est un peu plus compliqué (surtout non documenté en fait) ne considère pas que l'objet est centré et fait les subdivisions en se basant sur les pseudo normales aux points. Le premier est certainement celui qui t'intéresse, mais le deuxième doit générer la même chose dans ton exemple. Je peux expliquer la première méthode facilement. Pour chaque côté, on en insère un nouveau point aumilieu du côté et on normalise (pour qu'il soit à la même distance du centre que les points existants). Pour une face triangulaire, on obtient quatre faces, pour une face comportant plus de sommet, il faut en insérer un au milieux de la face et normaliser, ce qui donne autant de faces que de sommets (je pense que ce n'est absolument pas optimum de point de vu des points singuliers et compagnie). C'est vraiement simple, et pour cette méthode, le code ne te servira probablement à rien. Pour la deuxième méthode, si elle t'intéresse, regarde bien le code et essaye de faire des dessins. Je te prévient, aucune de ces méthodes n'ai supposée fonctionner dans tous les cas (ça fonctionne bien pour ce que j'en fait). Je ne prétend pas non plus les avoir inventées (mais juste au moins retrouvées en faisant des dessins). Pour ce qui est du code la pluspart des noms me paraissent explicites (mêmes quelques mois après l'avoir écrit), mais si tu as des questions sur les rôles des variables, n'hésite pas.

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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
procedure ComputePoint(P, PN, M : T3DVector; var RP : T3DVector);
var
   dot, a, L1, L, L_ : Float;
   k : boolean;
   T, NM : T3DVector;
 
begin
     dot := P[0] * PN[0] + P[1] * PN[1] + P[2] * PN[2];
     k := (dot < 0);
     PN := NormalizeT3DVector(PN)^;
     T[0] := P[0] - M[0];
     T[1] := P[1] - M[1];
     T[2] := P[2] - M[2];
     L1 := sqrt(sqr(T[0]) + sqr(T[1]) + sqr(T[2]));
     dot := abs(T[0] * PN[0] + T[1] * PN[1] + T[2] * PN[2]) / L1;
     if (round(dot*1e3) <> 0) then
     begin
          a := ArcCos(1 - dot);
          NM[0] := (PN[1] * T[2] - PN[2] * T[1]);
          NM[1] := (PN[2] * T[0] - PN[0] * T[2]);
          NM[2] := (PN[0] * T[1] - PN[1] * T[0]);
          NM := NormalizeT3DVector(NM)^;
          RP[0] := -(NM[1] * T[2] - NM[2] * T[1]);
          RP[1] := -(NM[2] * T[0] - NM[0] * T[2]);
          RP[2] := -(NM[0] * T[1] - NM[1] * T[0]);
          {RP[0] := (P[0] + RP[0]) div 2;
          RP[1] := (P[1] + RP[1]) div 2;
          RP[2] := (P[2] + RP[2]) div 2;}
          RP := NormalizeT3DVector(RP)^;
          L := L1 / dot;
          L_ := L1 / dot * sin(ArcCos(dot));
          L := (L - L_);
          if (k = true) then
          begin
               RP[0] := (M[0] - RP[0] * L);
               RP[1] := (M[1] - RP[1] * L);
               RP[2] := (M[2] - RP[2] * L);
          end
          else
          begin
               RP[0] := (M[0] + RP[0] * L);
               RP[1] := (M[1] + RP[1] * L);
               RP[2] := (M[2] + RP[2] * L);
          end;
     end
     else RP := M;
end;
 
procedure EndFace;
var
   Center, T : T3DVector;
   i : byte;
   TempTrans : T3DMatrix;
   TempDivNum : Int;
   Id, NId, {Points et normales ajout‚s sur les arrˆtes}
   TempId : array [0..MaxPoints + 1] of Int; {Points d'orrigine}
   M, {Milieux des c“t‚s}
   TempPoints : array [0..MaxPoints + 1] of T3DVector;
     {Points translat‚s par - DivideOrigin}
   MN : array [0..MaxPoints + 1] of T3DVector; {Normales des points des milieux}
   IdMid : Int; {Normale du centre}
   L, A : array [0..MaxPoints + 1] of Float;
   MidL : Float;
   P : array [0..MaxPoints + 1] of T3DVector; {Points spheric}
   AddL, AddR, Add : array [0..MaxPoints + 1] of T3DVector;
   TempBuildNum : Int;
   Length, dot, temp : Float;
   Pos : Int;
   TempFacesNum : Int;
 
begin
     if ((BuildFace = false) or
         ((BuildPoints <> BuildNormals) and (BuildNormals <> -1)) or
         (BuildPoints < 2)) then exit;
     BuildFace := false;
     Center := MakeT3DVector(0, 0, 0)^;
     for i := 0 to BuildPoints do
     begin
          TempId[i] := BuildPointsId[i]; {Points d'orrigine}
          Center[0] := Center[0] + Points^[BuildPointsId[i]].Coords[0];
          Center[1] := Center[1] + Points^[BuildPointsId[i]].Coords[1];
          Center[2] := Center[2] + Points^[BuildPointsId[i]].Coords[2];
          Faces^[FacesNum].Points[i] := BuildPointsId[i];
          Points^[Faces^[FacesNum].Points[i]].NId := BuildNormalsId[i]; {ýý}
     end;
     Center[0] := Center[0] / (BuildPoints + 1);
     Center[1] := Center[1] / (BuildPoints + 1);
     Center[2] := Center[2] / (BuildPoints + 1);
     TempDivNum := DivNum;
     TempFacesNum := FacesNum;
     T := GetNormal(Points^[Faces^[FacesNum].Points[0]].Coords,
                    Points^[Faces^[FacesNum].Points[1]].Coords,
                    Points^[Faces^[FacesNum].Points[2]].Coords)^;
     if (DivNum <> 0) then
     begin
          GetTrans(TempTrans);
          ResetTrans;
          Translate(DivideOrigin[0], DivideOrigin[1], DivideOrigin[2]);
          for i := 0 to BuildPoints do
          begin
               TempPoints[i, 0] := Points^[Faces^[FacesNum].Points[i]].Coords[0]
                                   - DivideOrigin[0];
               TempPoints[i, 1] := Points^[Faces^[FacesNum].Points[i]].Coords[1]
                                   - DivideOrigin[1];
               TempPoints[i, 2] := Points^[Faces^[FacesNum].Points[i]].Coords[2]
                                   - DivideOrigin[2];
          end;
          TempPoints[i + 1, 0] := Center[0] - DivideOrigin[0];
          TempPoints[i + 1, 1] := Center[1] - DivideOrigin[1];
          TempPoints[i + 1, 2] := Center[2] - DivideOrigin[2];
          if (DivStyle = sSpheric) then
          begin
               for i := 0 to BuildPoints do
               begin
                    L[i] := sqrt(sqr(TempPoints[i, 0]) +
                                 sqr(TempPoints[i, 1]) +
                                 sqr(TempPoints[i, 2]));
                    if (L[i] = 0) then L[i] := 1;
               end;
               for i := 0 to BuildPoints - 1 do
               begin
                    P[i, 0] := (TempPoints[i, 0] + TempPoints[i + 1][0]) / 2;
                    P[i, 1] := (TempPoints[i, 1] + TempPoints[i + 1][1]) / 2;
                    P[i, 2] := (TempPoints[i, 2] + TempPoints[i + 1][2]) / 2;
               end;
               P[BuildPoints, 0] := (TempPoints[BuildPoints][0] + TempPoints[0][0]) / 2;
               P[BuildPoints, 1] := (TempPoints[BuildPoints][1] + TempPoints[0][1]) / 2;
               P[BuildPoints, 2] := (TempPoints[BuildPoints][2] + TempPoints[0][2]) / 2;
               for i := 0 to BuildPoints do
               begin
                    A[i] := sqrt(sqr(P[i, 0]) + sqr(P[i, 1]) + sqr(P[i, 2]));
                    if (A[i] = 0) then A[i] := 1;
               end;
 
               for i := 0 to BuildPoints do
               begin
                    Id[i] := AddPoint((P[i, 0] * L[i] / A[i]),
                                      (P[i, 1] * L[i] / A[i]),
                                      (P[i, 2] * L[i] / A[i]));
                    NId[i] := AddNormal((P[i, 0] * L[i] / A[i]),
                                        (P[i, 1] * L[i] / A[i]),
                                        (P[i, 2] * L[i] / A[i]));
               end;
               if (BuildPoints > 2) then
               begin
                    MidL := 0;
                    for i := 0 to BuildPoints do
                      MidL := MidL + L[i];
                    MidL := MidL / (BuildPoints + 1);
                    P[BuildPoints + 1, 0] := (T[0] * MidL);
                    P[BuildPoints + 1, 1] := (T[1] * MidL);
                    P[BuildPoints + 1, 2] := (T[2] * MidL);
                    TempBuildNum := BuildPoints;
                    Id[BuildPoints + 1] := AddPoint(P[BuildPoints + 1, 0],
                                                    P[BuildPoints + 1, 1],
                                                    P[BuildPoints + 1, 2]);
                    NId[BuildPoints + 1] := AddNormal(T[0], T[1], T[2]);
                    Dec(FacesNum);
                    Dec(TotalFacesNum);
                    SetDivNum(DivNum - 1);
                    for i := 0 to TempBuildNum - 1 do
                    begin
                         BeginFace;
                           InsertPoint(Id[i]);
                           InsertNormal(NId[i]);
                           InsertPoint(TempId[i + 1]);
                           InsertNormal(Points^[TempId[i + 1]].NId);
                           InsertPoint(Id[i + 1]);
                           InsertNormal(NId[i + 1]);
                           InsertPoint(Id[TempBuildNum + 1]);
                           InsertNormal(NId[TempBuildNum + 1]);
                         EndFace;
                    end;
                    BeginFace;
                      InsertPoint(Id[TempBuildNum]);
                      InsertNormal(NId[TempBuildNum]);
                      InsertPoint(TempId[0]);
                      InsertNormal(Points^[TempId[0]].NId);
                      InsertPoint(Id[0]);
                      InsertNormal(NId[0]);
                      InsertPoint(Id[TempBuildNum + 1]);
                      InsertNormal(NId[TempBuildNum + 1]);
                    EndFace;
                    SetDivNum(TempDivNum);
               end
               else
               begin
                    TempBuildNum := BuildPoints;
                    Dec(FacesNum);
                    Dec(TotalFacesNum);
                    SetDivNum(DivNum - 1);
                    BeginFace;
                      InsertPoint(TempId[0]);
                      InsertNormal(Points^[TempId[0]].NId);
                      InsertPoint(Id[0]);
                      InsertNormal(NId[0]);
                      InsertPoint(Id[TempBuildNum]);
                      InsertNormal(NId[TempBuildNum]);
                    EndFace;
                    for i := 1 to TempBuildNum do
                    begin
                         BeginFace;
                           InsertPoint(TempId[i]);
                           InsertNormal(Points^[TempId[i]].NId);
                           InsertPoint(Id[i]);
                           InsertNormal(NId[i]);
                           InsertPoint(Id[i - 1]);
                           InsertNormal(NId[i - 1]);
                         EndFace;
                    end;
                    BeginFace;
                      for i := 0 to TempBuildNum do
                      begin
                           InsertPoint(Id[i]);
                           InsertNormal(NId[i]);
                      end;
                    EndFace;
                    SetDivNum(TempDivNum);
               end;
          end
          else
          begin
               TempBuildNum := BuildPoints;
               for i := 0 to TempBuildNum - 1 do
               begin
                    MN[i, 0] := (Normals^[Faces^[FacesNum].Points[i]][0] + Normals^[Faces^[FacesNum].Points[i + 1]][0]) / 2;
                    MN[i, 1] := (Normals^[Faces^[FacesNum].Points[i]][1] + Normals^[Faces^[FacesNum].Points[i + 1]][1]) / 2;
                    MN[i, 2] := (Normals^[Faces^[FacesNum].Points[i]][2] + Normals^[Faces^[FacesNum].Points[i + 1]][2]) / 2;
               end;
               MN[TempBuildNum, 0] :=
                 (Normals^[Faces^[FacesNum].Points[TempBuildNum]][0] +
                  Normals^[Faces^[FacesNum].Points[0]][0]) / 2;
               MN[TempBuildNum, 1] :=
                 (Normals^[Faces^[FacesNum].Points[TempBuildNum]][1] +
                  Normals^[Faces^[FacesNum].Points[0]][1]) / 2;
               MN[TempBuildNum, 2] :=
                 (Normals^[Faces^[FacesNum].Points[TempBuildNum]][2] +
                  Normals^[Faces^[FacesNum].Points[0]][2]) / 2;
               for i := 0 to TempBuildNum - 1 do
               begin
                    M[i, 0] := (TempPoints[i, 0] + TempPoints[i + 1][0]) / 2;
                    M[i, 1] := (TempPoints[i, 1] + TempPoints[i + 1][1]) / 2;
                    M[i, 2] := (TempPoints[i, 2] + TempPoints[i + 1][2]) / 2;
               end;
               M[TempBuildNum, 0] := (TempPoints[TempBuildNum][0] + TempPoints[0][0]) / 2;
               M[TempBuildNum, 1] := (TempPoints[TempBuildNum][1] + TempPoints[0][1]) / 2;
               M[TempBuildNum, 2] := (TempPoints[TempBuildNum][2] + TempPoints[0][2]) / 2;
               for i := 0 to TempBuildNum - 1 do
               begin
                    ComputePoint(TempPoints[i],
                                 Normals^[Faces^[FacesNum].Points[i]],
                                 M[i], AddL[i]);
                    ComputePoint(TempPoints[i + 1],
                                 Normals^[Faces^[FacesNum].Points[i + 1]],
                                 M[i], AddR[i]);
               end;
               ComputePoint(TempPoints[TempBuildNum],
                            Normals^[Faces^[FacesNum].Points[TempBuildNum]],
                            M[TempBuildNum], AddL[TempBuildNum]);
               ComputePoint(TempPoints[0],
                            Normals^[Faces^[FacesNum].Points[0]],
                            M[TempBuildNum], AddR[TempBuildNum]);
               if (XMSEnabled) then
               begin
                    for i := 0 to BuildPoints - 1 do
                    begin
                         XMSGetAtInt(DivArray, BuildPointsId[i], BuildPointsId[i + 1], Id[i]);
                         NId[i] := -2;
                    end;
                    XMSGetAtInt(DivArray, BuildPointsId[BuildPoints], BuildPointsId[0], Id[BuildPoints]);
                    NId[BuildPoints] := -2;
                    for i := 0 to BuildPoints - 1 do
                    begin
                         if (Id[i] = -1) then
                         begin
                              Id[i] := AddPoint((P[i, 0] * L[i] / A[i]),
                                                (P[i, 1] * L[i] / A[i]),
                                                (P[i, 2] * L[i] / A[i]));
                              XMSPutAtInt(DivArray, BuildPointsId[i], BuildPointsId[i + 1], Id[i]);
                              XMSPutAtInt(DivArray, BuildPointsId[i + 1], BuildPointsId[i], Id[i]);
                         end;
                    end;
                    if (Id[BuildPoints] = -1) then
                    begin
                         Id[BuildPoints] := AddPoint((P[BuildPoints, 0] * L[BuildPoints] / A[BuildPoints]),
                                                     (P[BuildPoints, 1] * L[BuildPoints] / A[BuildPoints]),
                                                     (P[BuildPoints, 2] * L[BuildPoints] / A[BuildPoints]));
                         XMSPutAtInt(DivArray, BuildPointsId[0], BuildPointsId[BuildPoints], Id[BuildPoints]);
                         XMSPutAtInt(DivArray, BuildPointsId[BuildPoints], BuildPointsId[0], Id[BuildPoints]);
                    end;
               end
               else
               begin
                    for i := 0 to BuildPoints do
                    begin
                         Id[i] := AddPoint((AddR[i, 0] + AddL[i, 0]) / 2,
                                           (AddR[i, 1] + AddL[i, 1]) / 2,
                                           (AddR[i, 2] + AddL[i, 2]) / 2);
                         NId[i] := AddNormal(
                           (Normals^[Faces^[FacesNum].Points[i]][0] +
                            Normals^[Faces^[FacesNum].Points[i + 1]][0]) / 2,
                           (Normals^[Faces^[FacesNum].Points[i]][1] +
                            Normals^[Faces^[FacesNum].Points[i + 1]][1]) / 2,
                           (Normals^[Faces^[FacesNum].Points[i]][2] +
                            Normals^[Faces^[FacesNum].Points[i + 1]][2]) / 2);
                    end;
                    Id[TempBuildNum] := AddPoint((AddR[TempBuildNum, 0] +
                                                  AddL[TempBuildNum, 0]) / 2,
                                                 (AddR[TempBuildNum, 1] +
                                                  AddL[TempBuildNum, 1]) / 2,
                                                 (AddR[TempBuildNum, 2] +
                                                  AddL[TempBuildNum, 2]) / 2);
                    NId[TempBuildNum] := AddNormal(
                      (Normals^[Faces^[FacesNum].Points[TempBuildNum]][0] +
                       Normals^[Faces^[FacesNum].Points[0]][0]) / 2,
                      (Normals^[Faces^[FacesNum].Points[TempBuildNum]][1] +
                       Normals^[Faces^[FacesNum].Points[0]][1]) / 2,
                      (Normals^[Faces^[FacesNum].Points[TempBuildNum]][2] +
                       Normals^[Faces^[FacesNum].Points[0]][2]) / 2);
               end;
               if (TempBuildNum > 2) then
               begin
                    for i := 0 to TempBuildNum do
                      ComputePoint(TempPoints[i],
                                   Normals^[Faces^[FacesNum].Points[i]],
                                   TempPoints[TempBuildNum + 1], Add[i]);
                    Add[MaxPoints + 1, 0] := 0;
                    Add[MaxPoints + 1, 1] := 0;
                    Add[MaxPoints + 1, 2] := 0;
                    for i := 0 to TempBuildNum do
                    begin
                         Add[MaxPoints + 1, 0] := Add[i, 0] + Add[MaxPoints + 1, 0];
                         Add[MaxPoints + 1, 1] := Add[i, 1] + Add[MaxPoints + 1, 1];
                         Add[MaxPoints + 1, 2] := Add[i, 2] + Add[MaxPoints + 1, 2];
                    end;
                    Add[MaxPoints + 1, 0] := Add[MaxPoints + 1, 0] / (TempBuildNum + 1);
                    Add[MaxPoints + 1, 1] := Add[MaxPoints + 1, 1] / (TempBuildNum + 1);
                    Add[MaxPoints + 1, 2] := Add[MaxPoints + 1, 2] / (TempBuildNum + 1);
                    if ((Add[MaxPoints + 1, 0] <> TempPoints[TempBuildNum + 1][0]) or
                        (Add[MaxPoints + 1, 1] <> TempPoints[TempBuildNum + 1][1]) or
                        (Add[MaxPoints + 1, 2] <> TempPoints[TempBuildNum + 1][2])) then
                    begin
                         Id[MaxPoints + 1] := AddPoint(Add[MaxPoints + 1, 0],
                                                  Add[MaxPoints + 1, 1],
                                                  Add[MaxPoints + 1, 2]);
                         IdMid := AddNormal(T[0],
                                            T[1],
                                            T[2]);
                         Dec(FacesNum);
                         Dec(TotalFacesNum);
                         SetDivNum(DivNum - 1);
                         for i := 0 to TempBuildNum - 1 do
                         begin
                              BeginFace;
                                InsertPoint(Id[MaxPoints + 1]);
                                InsertNormal(IdMid);
                                InsertPoint(TempId[i]);
                                InsertNormal(Points^[TempId[i]].NId);
                                InsertPoint(Id[i]);
                                InsertNormal(NId[i]);
                              EndFace;
                              BeginFace;
                                InsertPoint(TempId[i + 1]);
                                InsertNormal(Points^[TempId[i + 1]].NId);
                                InsertPoint(Id[MaxPoints + 1]);
                                InsertNormal(IdMid);
                                InsertPoint(Id[i]);
                                InsertNormal(NId[i]);
                              EndFace;
                         end;
                         BeginFace;
                           InsertPoint(Id[MaxPoints + 1]);
                           InsertNormal(IdMid);
                           InsertPoint(TempId[TempBuildNum]);
                           InsertNormal(Points^[TempId[TempBuildNum]].NId);
                           InsertPoint(Id[TempBuildNum]);
                           InsertNormal(NId[TempBuildNum]);
                         EndFace;
                         BeginFace;
                           InsertPoint(TempId[0]);
                           InsertNormal(Points^[TempId[0]].NId);
                           InsertPoint(Id[MaxPoints + 1]);
                           InsertNormal(IdMid);
                           InsertPoint(Id[TempBuildNum]);
                           InsertNormal(NId[TempBuildNum]);
                         EndFace;
                         SetDivNum(TempDivNum);
                    end;
               end
               else
               begin
                    Dec(FacesNum);
                    Dec(TotalFacesNum);
                    SetDivNum(DivNum - 1);
                    BeginFace;
                      InsertPoint(Id[TempBuildNum]);
                      InsertNormal(NId[TempBuildNum]);
                      InsertPoint(TempId[0]);
                      InsertNormal(Points^[TempId[0]].NId);
                      InsertPoint(Id[0]);
                      InsertNormal(NId[0]);
                    EndFace;
                    for i := 1 to TempBuildNum do
                    begin
                         BeginFace;
                           InsertPoint(Id[i - 1]);
                           InsertNormal(NId[i - 1]);
                           InsertPoint(TempId[i]);
                           InsertNormal(Points^[TempId[i]].NId);
                           InsertPoint(Id[i]);
                           InsertNormal(NId[i]);
                         EndFace;
                    end;
                    BeginFace;
                      InsertPoint(Id[0]);
                      InsertNormal(NId[0]);
                      InsertPoint(Id[1]);
                      InsertNormal(NId[1]);
                      InsertPoint(Id[2]);
                      InsertNormal(NId[2]);
                    EndFace;
               end;
               SetDivNum(TempDivNum);
          end;
          SetTrans(TempTrans);
     end
     else
     begin
          Faces^[FacesNum].PointsNum := BuildPoints;
          Faces^[FacesNum].RenderMode := RenderMode;
          Faces^[FacesNum].RemoveBackFaces := BuildRemove;
          TempTrans := Trans;
          ResetTrans;
          Faces^[FacesNum].Normal := AddNormal(T[0], T[1], T[2]);
          Faces^[FacesNum].Center := AddPoint(Center[0], Center[1], Center[2]);
          Trans := TempTrans;
          Faces^[FacesNum].Color := RGB(DefaultR, DefaultG, DefaultB);
     end;
end;