Quite compiler warnings.
[blender-staging.git] / source / blender / freestyle / intern / blender_interface / BlenderFileLoader.cpp
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * ***** END GPL LICENSE BLOCK *****
19  */
20
21 /** \file blender/freestyle/intern/blender_interface/BlenderFileLoader.cpp
22  *  \ingroup freestyle
23  */
24
25 #include "BlenderFileLoader.h"
26
27 #include "BLI_utildefines.h"
28
29 #include "BKE_global.h"
30
31 namespace Freestyle {
32
33 BlenderFileLoader::BlenderFileLoader(Render *re, SceneRenderLayer *srl)
34 {
35         _re = re;
36         _srl = srl;
37         _Scene = NULL;
38         _numFacesRead = 0;
39         _minEdgeSize = DBL_MAX;
40         _smooth = (srl->freestyleConfig.flags & FREESTYLE_FACE_SMOOTHNESS_FLAG) != 0;
41 }
42
43 BlenderFileLoader::~BlenderFileLoader()
44 {
45         _Scene = NULL;
46 }
47
48 NodeGroup *BlenderFileLoader::Load()
49 {
50         ObjectInstanceRen *obi;
51
52         if (G.debug & G_DEBUG_FREESTYLE) {
53                 cout << "\n===  Importing triangular meshes into Blender  ===" << endl;
54         }
55
56         // creation of the scene root node
57         _Scene = new NodeGroup;
58
59         _viewplane_left =   _re->viewplane.xmin;
60         _viewplane_right =  _re->viewplane.xmax;
61         _viewplane_bottom = _re->viewplane.ymin;
62         _viewplane_top =    _re->viewplane.ymax;
63
64         if ((_re->r.scemode & R_VIEWPORT_PREVIEW) && (_re->r.mode & R_ORTHO)) {
65                 // Adjust clipping start/end and set up a Z offset when the viewport preview
66                 // is used with the orthographic view.  In this case, _re->clipsta is negative,
67                 // while Freestyle assumes that imported mesh data are in the camera coordinate
68                 // system with the view point located at origin [bug #36009].
69                 BLI_assert(_re->clipsta < 0.f);
70                 _z_near = -0.001f;
71                 _z_offset = _re->clipsta + _z_near;
72                 _z_far = -_re->clipend + _z_offset;
73         }
74         else {
75                 _z_near = -_re->clipsta;
76                 _z_far = -_re->clipend;
77                 _z_offset = 0.f;
78         }
79
80 #if 0
81         if (G.debug & G_DEBUG_FREESTYLE) {
82                 cout << "Frustum: l " << _viewplane_left << " r " << _viewplane_right
83                      << " b " << _viewplane_bottom << " t " << _viewplane_top
84                      << " n " << _z_near << " f " << _z_far << endl;
85         }
86 #endif
87
88         int id = 0;
89         for (obi = (ObjectInstanceRen *)_re->instancetable.first; obi; obi = obi->next) {
90                 if (_pRenderMonitor && _pRenderMonitor->testBreak())
91                         break;
92                 if (!(obi->lay & _srl->lay))
93                         continue;
94                 char *name = obi->ob->id.name;
95                 //printf("%c%c:%s\n", name[0], name[1], name+2);
96                 //print_m4("obi->mat", obi->mat);
97
98                 if (obi->obr->totvlak > 0) {
99                         insertShapeNode(obi, ++id);
100                 }
101                 else if (G.debug & G_DEBUG_FREESTYLE) {
102                         cout << "Warning: " << (name + 2) << " is not a vlak-based object (ignored)" << endl;
103                 }
104         }
105
106         // Return the built scene.
107         return _Scene;
108 }
109
110 #define CLIPPED_BY_NEAR -1
111 #define NOT_CLIPPED      0
112 #define CLIPPED_BY_FAR   1
113
114 // check if each vertex of a triangle (V1, V2, V3) is clipped by the near/far plane
115 // and calculate the number of triangles to be generated by clipping
116 int BlenderFileLoader::countClippedFaces(float v1[3], float v2[3], float v3[3], int clip[3])
117 {
118         float *v[3];
119         int numClipped, sum, numTris = 0;
120
121         v[0] = v1;
122         v[1] = v2;
123         v[2] = v3;
124         numClipped = sum = 0;
125         for (int i = 0; i < 3; i++) {
126                 if (v[i][2] > _z_near) {
127                         clip[i] = CLIPPED_BY_NEAR;
128                         numClipped++;
129                 }
130                 else if (v[i][2] < _z_far) {
131                         clip[i] = CLIPPED_BY_FAR;
132                         numClipped++;
133                 }
134                 else {
135                         clip[i] = NOT_CLIPPED;
136                 }
137 #if 0
138                 if (G.debug & G_DEBUG_FREESTYLE) {
139                         printf("%d %s\n", i, (clip[i] == NOT_CLIPPED) ? "not" : (clip[i] == CLIPPED_BY_NEAR) ? "near" : "far");
140                 }
141 #endif
142                 sum += clip[i];
143         }
144         switch (numClipped) {
145         case 0:
146                 numTris = 1; // triangle
147                 break;
148         case 1:
149                 numTris = 2; // tetragon
150                 break;
151         case 2:
152                 if (sum == 0)
153                         numTris = 3; // pentagon
154                 else
155                         numTris = 1; // triangle
156                 break;
157         case 3:
158                 if (sum == 3 || sum == -3)
159                         numTris = 0;
160                 else
161                         numTris = 2; // tetragon
162                 break;
163         }
164         return numTris;
165 }
166
167 // find the intersection point C between the line segment from V1 to V2 and
168 // a clipping plane at depth Z (i.e., the Z component of C is known, while
169 // the X and Y components are unknown).
170 void BlenderFileLoader::clipLine(float v1[3], float v2[3], float c[3], float z)
171 {
172         // Order v1 and v2 by Z values to make sure that clipLine(P, Q, c, z)
173         // and clipLine(Q, P, c, z) gives exactly the same numerical result.
174         float *p, *q;
175         if (v1[2] < v2[2]) {
176                 p = v1;
177                 q = v2;
178         }
179         else {
180                 p = v2;
181                 q = v1;
182         }
183         double d[3];
184         for (int i = 0; i < 3; i++)
185                 d[i] = q[i] - p[i];
186         double t = (z - p[2]) / d[2];
187         c[0] = p[0] + t * d[0];
188         c[1] = p[1] + t * d[1];
189         c[2] = z;
190 }
191
192 // clip the triangle (V1, V2, V3) by the near and far clipping plane and
193 // obtain a set of vertices after the clipping.  The number of vertices
194 // is at most 5.
195 void BlenderFileLoader::clipTriangle(int numTris, float triCoords[][3], float v1[3], float v2[3], float v3[3],
196                                      float triNormals[][3], float n1[3], float n2[3], float n3[3],
197                                      bool edgeMarks[], bool em1, bool em2, bool em3, int clip[3])
198 {
199         float *v[3], *n[3];
200         bool em[3];
201         int i, j, k;
202
203         v[0] = v1; n[0] = n1;
204         v[1] = v2; n[1] = n2;
205         v[2] = v3; n[2] = n3;
206         em[0] = em1; /* edge mark of the edge between v1 and v2 */
207         em[1] = em2; /* edge mark of the edge between v2 and v3 */
208         em[2] = em3; /* edge mark of the edge between v3 and v1 */
209         k = 0;
210         for (i = 0; i < 3; i++) {
211                 j = (i + 1) % 3;
212                 if (clip[i] == NOT_CLIPPED) {
213                         copy_v3_v3(triCoords[k], v[i]);
214                         copy_v3_v3(triNormals[k], n[i]);
215                         edgeMarks[k] = em[i];
216                         k++;
217                         if (clip[j] != NOT_CLIPPED) {
218                                 clipLine(v[i], v[j], triCoords[k], (clip[j] == CLIPPED_BY_NEAR) ? _z_near : _z_far);
219                                 copy_v3_v3(triNormals[k], n[j]);
220                                 edgeMarks[k] = false;
221                                 k++;
222                         }
223                 }
224                 else if (clip[i] != clip[j]) {
225                         if (clip[j] == NOT_CLIPPED) {
226                                 clipLine(v[i], v[j], triCoords[k], (clip[i] == CLIPPED_BY_NEAR) ? _z_near : _z_far);
227                                 copy_v3_v3(triNormals[k], n[i]);
228                                 edgeMarks[k] = em[i];
229                                 k++;
230                         }
231                         else {
232                                 clipLine(v[i], v[j], triCoords[k], (clip[i] == CLIPPED_BY_NEAR) ? _z_near : _z_far);
233                                 copy_v3_v3(triNormals[k], n[i]);
234                                 edgeMarks[k] = em[i];
235                                 k++;
236                                 clipLine(v[i], v[j], triCoords[k], (clip[j] == CLIPPED_BY_NEAR) ? _z_near : _z_far);
237                                 copy_v3_v3(triNormals[k], n[j]);
238                                 edgeMarks[k] = false;
239                                 k++;
240                         }
241                 }
242         }
243         BLI_assert(k == 2 + numTris);
244 }
245
246 void BlenderFileLoader::addTriangle(struct LoaderState *ls, float v1[3], float v2[3], float v3[3],
247                                     float n1[3], float n2[3], float n3[3],
248                                     bool fm, bool em1, bool em2, bool em3)
249 {
250         float *fv[3], *fn[3], len;
251         unsigned int i, j;
252         IndexedFaceSet::FaceEdgeMark marks = 0;
253
254         // initialize the bounding box by the first vertex
255         if (ls->currentIndex == 0) {
256                 copy_v3_v3(ls->minBBox, v1);
257                 copy_v3_v3(ls->maxBBox, v1);
258         }
259
260         fv[0] = v1; fn[0] = n1;
261         fv[1] = v2; fn[1] = n2;
262         fv[2] = v3; fn[2] = n3;
263         for (i = 0; i < 3; i++) {
264
265                 copy_v3_v3(ls->pv, fv[i]);
266                 copy_v3_v3(ls->pn, fn[i]);
267
268                 // update the bounding box
269                 for (j = 0; j < 3; j++) {
270                         if (ls->minBBox[j] > ls->pv[j])
271                                 ls->minBBox[j] = ls->pv[j];
272
273                         if (ls->maxBBox[j] < ls->pv[j])
274                                 ls->maxBBox[j] = ls->pv[j];
275                 }
276
277                 len = len_v3v3(fv[i], fv[(i + 1) % 3]);
278                 if (_minEdgeSize > len)
279                         _minEdgeSize = len;
280
281                 *ls->pvi = ls->currentIndex;
282                 *ls->pni = ls->currentIndex;
283                 *ls->pmi = ls->currentMIndex;
284
285                 ls->currentIndex += 3;
286                 ls->pv += 3;
287                 ls->pn += 3;
288
289                 ls->pvi++;
290                 ls->pni++;
291                 ls->pmi++;
292         }
293
294         if (fm)
295                 marks |= IndexedFaceSet::FACE_MARK;
296         if (em1)
297                 marks |= IndexedFaceSet::EDGE_MARK_V1V2;
298         if (em2)
299                 marks |= IndexedFaceSet::EDGE_MARK_V2V3;
300         if (em3)
301                 marks |= IndexedFaceSet::EDGE_MARK_V3V1;
302         *(ls->pm++) = marks;
303 }
304
305 // With A, B and P indicating the three vertices of a given triangle, returns:
306 // 1 if points A and B are in the same position in the 3D space;
307 // 2 if the distance between point P and line segment AB is zero; and
308 // zero otherwise.
309 int BlenderFileLoader::testDegenerateTriangle(float v1[3], float v2[3], float v3[3])
310 {
311         const float eps = 1.0e-6;
312         const float eps_sq = eps * eps;
313
314 #if 0
315         float area = area_tri_v3(v1, v2, v3);
316         bool verbose = (area < 1.0e-6);
317 #endif
318
319         if (equals_v3v3(v1, v2) || equals_v3v3(v2, v3) || equals_v3v3(v1, v3)) {
320 #if 0
321                 if (verbose && G.debug & G_DEBUG_FREESTYLE) {
322                         printf("BlenderFileLoader::testDegenerateTriangle = 1\n");
323                 }
324 #endif
325                 return 1;
326         }
327         if (dist_squared_to_line_segment_v3(v1, v2, v3) < eps_sq ||
328             dist_squared_to_line_segment_v3(v2, v1, v3) < eps_sq ||
329             dist_squared_to_line_segment_v3(v3, v1, v2) < eps_sq)
330         {
331 #if 0
332                 if (verbose && G.debug & G_DEBUG_FREESTYLE) {
333                         printf("BlenderFileLoader::testDegenerateTriangle = 2\n");
334                 }
335 #endif
336                 return 2;
337         }
338 #if 0
339         if (verbose && G.debug & G_DEBUG_FREESTYLE) {
340                 printf("BlenderFileLoader::testDegenerateTriangle = 0\n");
341         }
342 #endif
343         return 0;
344 }
345
346 // Checks if edge rotation (if necessary) can prevent the given quad from
347 // being decomposed into a degenerate triangle
348 bool BlenderFileLoader::testEdgeRotation(float v1[3], float v2[3], float v3[3], float v4[3])
349 {
350         if (testDegenerateTriangle(v1, v2, v3) == 2 || testDegenerateTriangle(v1, v3, v4) == 2) {
351                 if (testDegenerateTriangle(v1, v2, v4) == 2 || testDegenerateTriangle(v2, v3, v4) == 2) {
352 #if 0
353                         if (G.debug & G_DEBUG_FREESTYLE) {
354                                 printf("BlenderFileLoader::testEdgeRotation: edge rotation is unsuccessful.\n");
355                         }
356 #endif
357                         return false;
358                 }
359                 return true;
360         }
361         return false;
362 }
363
364 void BlenderFileLoader::insertShapeNode(ObjectInstanceRen *obi, int id)
365 {
366         ObjectRen *obr = obi->obr;
367         char *name = obi->ob->id.name + 2;
368
369         // We parse vlak nodes and count the number of faces after the clipping by
370         // the near and far view planes is applied (Note: mesh vertices are in the
371         // camera coordinate system).
372         VlakRen *vlr = NULL;
373         unsigned numFaces = 0;
374         float v1[3], v2[3], v3[3], v4[3];
375         float n1[3], n2[3], n3[3], n4[3], facenormal[3];
376         int clip_1[3], clip_2[3];
377         int wire_material = 0;
378         for (int a = 0; a < obr->totvlak; a++) {
379                 if ((a & 255) == 0)
380                         vlr = obr->vlaknodes[a>>8].vlak;
381                 else
382                         vlr++;
383                 if (vlr->mat->material_type == MA_TYPE_WIRE) {
384                         wire_material = 1;
385                         continue;
386                 }
387                 copy_v3_v3(v1, vlr->v1->co);
388                 copy_v3_v3(v2, vlr->v2->co);
389                 copy_v3_v3(v3, vlr->v3->co);
390                 if (vlr->v4)
391                         copy_v3_v3(v4, vlr->v4->co);
392                 if (obi->flag & R_TRANSFORMED) {
393                         mul_m4_v3(obi->mat, v1);
394                         mul_m4_v3(obi->mat, v2);
395                         mul_m4_v3(obi->mat, v3);
396                         if (vlr->v4)
397                                 mul_m4_v3(obi->mat, v4);
398                 }
399                 v1[2] += _z_offset;
400                 v2[2] += _z_offset;
401                 v3[2] += _z_offset;
402                 if (vlr->v4)
403                         v4[2] += _z_offset;
404 #if 0
405                 print_v3("v1", v1);
406                 print_v3("v2", v2);
407                 print_v3("v3", v3);
408                 if (vlr->v4)
409                         print_v3("v4", v4);
410 #endif
411                 if (!vlr->v4 || !testEdgeRotation(v1, v2, v3, v4)) {
412                         numFaces += countClippedFaces(v1, v2, v3, clip_1);
413                         if (vlr->v4)
414                                 numFaces += countClippedFaces(v1, v3, v4, clip_2);
415                 }
416                 else {
417                         numFaces += countClippedFaces(v1, v2, v4, clip_1);
418                         numFaces += countClippedFaces(v2, v3, v4, clip_2);
419                 }
420         }
421         if (wire_material) {
422                 if (G.debug & G_DEBUG_FREESTYLE) {
423                         cout << "Warning: Object " << name << " has wire materials (ignored)" << endl;
424                 }
425         }
426 #if 0
427         if (G.debug & G_DEBUG_FREESTYLE) {
428                 cout << "numFaces " << numFaces << endl;
429         }
430 #endif
431         if (numFaces == 0)
432                 return;
433
434         // We allocate memory for the meshes to be imported
435         NodeTransform *currentMesh = new NodeTransform;
436         NodeShape *shape = new NodeShape;
437
438         unsigned vSize = 3 * 3 * numFaces;
439         float *vertices = new float[vSize];
440         unsigned nSize = vSize;
441         float *normals = new float[nSize];
442         unsigned *numVertexPerFaces = new unsigned[numFaces];
443         vector<FrsMaterial> meshFrsMaterials;
444
445         IndexedFaceSet::TRIANGLES_STYLE *faceStyle = new IndexedFaceSet::TRIANGLES_STYLE[numFaces];
446         unsigned i;
447         for (i = 0; i <numFaces; i++) {
448                 faceStyle[i] = IndexedFaceSet::TRIANGLES;
449                 numVertexPerFaces[i] = 3;
450         }
451
452         IndexedFaceSet::FaceEdgeMark *faceEdgeMarks = new IndexedFaceSet::FaceEdgeMark[numFaces];
453
454         unsigned viSize = 3 * numFaces;
455         unsigned *VIndices = new unsigned[viSize];
456         unsigned niSize = viSize;
457         unsigned *NIndices = new unsigned[niSize];
458         unsigned *MIndices = new unsigned[viSize]; // Material Indices
459
460         struct LoaderState ls;
461         ls.pv = vertices;
462         ls.pn = normals;
463         ls.pm = faceEdgeMarks;
464         ls.pvi = VIndices;
465         ls.pni = NIndices;
466         ls.pmi = MIndices;
467         ls.currentIndex = 0;
468         ls.currentMIndex = 0;
469
470         FrsMaterial tmpMat;
471
472         // We parse the vlak nodes again and import meshes while applying the clipping
473         // by the near and far view planes.
474         int p;
475         for (p = 0; p < obr->totvlak; ++p) { // we parse the faces of the mesh
476 #if 0
477                 Lib3dsFace *f = &mesh->faceL[p];
478                 Lib3dsMaterial *mat = NULL;
479 #endif
480                 if ((p & 255) == 0)
481                         vlr = obr->vlaknodes[p>>8].vlak;
482                 else
483                         vlr++;
484                 if (vlr->mat->material_type == MA_TYPE_WIRE)
485                         continue;
486                 copy_v3_v3(v1, vlr->v1->co);
487                 copy_v3_v3(v2, vlr->v2->co);
488                 copy_v3_v3(v3, vlr->v3->co);
489                 if (vlr->v4)
490                         copy_v3_v3(v4, vlr->v4->co);
491                 if (obi->flag & R_TRANSFORMED) {
492                         mul_m4_v3(obi->mat, v1);
493                         mul_m4_v3(obi->mat, v2);
494                         mul_m4_v3(obi->mat, v3);
495                         if (vlr->v4)
496                                 mul_m4_v3(obi->mat, v4);
497                 }
498                 v1[2] += _z_offset;
499                 v2[2] += _z_offset;
500                 v3[2] += _z_offset;
501                 if (vlr->v4)
502                         v4[2] += _z_offset;
503                 if (_smooth && (vlr->flag & R_SMOOTH)) {
504                         copy_v3_v3(n1, vlr->v1->n);
505                         copy_v3_v3(n2, vlr->v2->n);
506                         copy_v3_v3(n3, vlr->v3->n);
507                         if (vlr->v4)
508                                 copy_v3_v3(n4, vlr->v4->n);
509                         if (obi->flag & R_TRANSFORMED) {
510                                 mul_m3_v3(obi->nmat, n1);
511                                 mul_m3_v3(obi->nmat, n2);
512                                 mul_m3_v3(obi->nmat, n3);
513                                 normalize_v3(n1);
514                                 normalize_v3(n2);
515                                 normalize_v3(n3);
516                                 if (vlr->v4) {
517                                         mul_m3_v3(obi->nmat, n4);
518                                         normalize_v3(n4);
519                                 }
520                         }
521                 }
522                 else {
523                         RE_vlakren_get_normal(_re, obi, vlr, facenormal);
524                         copy_v3_v3(n1, facenormal);
525                         copy_v3_v3(n2, facenormal);
526                         copy_v3_v3(n3, facenormal);
527                         if (vlr->v4)
528                                 copy_v3_v3(n4, facenormal);
529                 }
530
531                 unsigned int numTris_1, numTris_2;
532                 bool edge_rotation;
533                 if (!vlr->v4 || !testEdgeRotation(v1, v2, v3, v4)) {
534                         numTris_1 = countClippedFaces(v1, v2, v3, clip_1);
535                         numTris_2 = (!vlr->v4) ? 0 : countClippedFaces(v1, v3, v4, clip_2);
536                         edge_rotation = false;
537                 }
538                 else {
539                         numTris_1 = countClippedFaces(v1, v2, v4, clip_1);
540                         numTris_2 = countClippedFaces(v2, v3, v4, clip_2);
541                         edge_rotation = true;
542                         if (G.debug & G_DEBUG_FREESTYLE) {
543                                 printf("BlenderFileLoader::insertShapeNode: edge rotation is performed.\n");
544                         }
545                 }
546                 if (numTris_1 == 0 && numTris_2 == 0)
547                         continue;
548                 bool fm, em1, em2, em3, em4;
549                 fm = (vlr->freestyle_face_mark) != 0;
550                 em1 = (vlr->freestyle_edge_mark & R_EDGE_V1V2) != 0;
551                 em2 = (vlr->freestyle_edge_mark & R_EDGE_V2V3) != 0;
552                 if (!vlr->v4) {
553                         em3 = (vlr->freestyle_edge_mark & R_EDGE_V3V1) != 0;
554                         em4 = false;
555                 }
556                 else {
557                         em3 = (vlr->freestyle_edge_mark & R_EDGE_V3V4) != 0;
558                         em4 = (vlr->freestyle_edge_mark & R_EDGE_V4V1) != 0;
559                 }
560
561                 Material *mat = vlr->mat;
562                 if (mat) {
563                         tmpMat.setDiffuse(mat->r, mat->g, mat->b, mat->alpha);
564                         tmpMat.setSpecular(mat->specr, mat->specg, mat->specb, mat->spectra);
565                         float s = 1.0 * (mat->har + 1) / 4 ; // in Blender: [1;511] => in OpenGL: [0;128]
566                         if (s > 128.f)
567                                 s = 128.f;
568                         tmpMat.setShininess(s);
569                 }
570
571                 if (meshFrsMaterials.empty()) {
572                         meshFrsMaterials.push_back(tmpMat);
573                         shape->setFrsMaterial(tmpMat);
574                 }
575                 else {
576                         // find if the material is already in the list
577                         unsigned int i = 0;
578                         bool found = false;
579
580                         for (vector<FrsMaterial>::iterator it = meshFrsMaterials.begin(), itend = meshFrsMaterials.end();
581                              it != itend;
582                              it++, i++)
583                         {
584                                 if (*it == tmpMat) {
585                                         ls.currentMIndex = i;
586                                         found = true;
587                                         break;
588                                 }
589                         }
590
591                         if (!found) {
592                                 meshFrsMaterials.push_back(tmpMat);
593                                 ls.currentMIndex = meshFrsMaterials.size() - 1;
594                         }
595                 }
596
597                 float triCoords[5][3], triNormals[5][3];
598                 bool edgeMarks[5]; // edgeMarks[i] is for the edge between i-th and (i+1)-th vertices
599
600                 if (numTris_1 > 0) {
601                         if (!edge_rotation) {
602                                 clipTriangle(numTris_1, triCoords, v1, v2, v3, triNormals, n1, n2, n3,
603                                              edgeMarks, em1, em2, (!vlr->v4) ? em3 : false, clip_1);
604                         }
605                         else {
606                                 clipTriangle(numTris_1, triCoords, v1, v2, v4, triNormals, n1, n2, n4,
607                                              edgeMarks, em1, false, em4, clip_1);
608                         }
609                         for (i = 0; i < numTris_1; i++) {
610                                 addTriangle(&ls, triCoords[0], triCoords[i + 1], triCoords[i + 2],
611                                             triNormals[0], triNormals[i + 1], triNormals[i + 2],
612                                             fm, (i == 0) ? edgeMarks[0] : false, edgeMarks[i + 1],
613                                             (i == numTris_1 - 1) ? edgeMarks[i + 2] : false);
614                                 _numFacesRead++;
615                         }
616                 }
617
618                 if (numTris_2 > 0) {
619                         if (!edge_rotation) {
620                                 clipTriangle(numTris_2, triCoords, v1, v3, v4, triNormals, n1, n3, n4,
621                                              edgeMarks, false, em3, em4, clip_2);
622                         }
623                         else {
624                                 clipTriangle(numTris_2, triCoords, v2, v3, v4, triNormals, n2, n3, n4,
625                                              edgeMarks, em2, em3, false, clip_2);
626                         }
627                         for (i = 0; i < numTris_2; i++) {
628                                 addTriangle(&ls, triCoords[0], triCoords[i + 1], triCoords[i + 2],
629                                             triNormals[0], triNormals[i + 1], triNormals[i + 2],
630                                             fm, (i == 0) ? edgeMarks[0] : false, edgeMarks[i + 1],
631                                             (i == numTris_2 - 1) ? edgeMarks[i + 2] : false);
632                                 _numFacesRead++;
633                         }
634                 }
635         }
636
637         // We might have several times the same vertex. We want a clean 
638         // shape with no real-vertex. Here, we are making a cleaning pass.
639         real *cleanVertices = NULL;
640         unsigned int cvSize;
641         unsigned int *cleanVIndices = NULL;
642
643         GeomCleaner::CleanIndexedVertexArray(vertices, vSize, VIndices, viSize, &cleanVertices, &cvSize, &cleanVIndices);
644
645         real *cleanNormals = NULL;
646         unsigned int cnSize;
647         unsigned int *cleanNIndices = NULL;
648
649         GeomCleaner::CleanIndexedVertexArray(normals, nSize, NIndices, niSize, &cleanNormals, &cnSize, &cleanNIndices);
650
651         // format materials array
652         FrsMaterial **marray = new FrsMaterial *[meshFrsMaterials.size()];
653         unsigned int mindex = 0;
654         for (vector<FrsMaterial>::iterator m = meshFrsMaterials.begin(), mend = meshFrsMaterials.end(); m != mend; ++m) {
655                 marray[mindex] = new FrsMaterial(*m);
656                 ++mindex;
657         }
658
659         // deallocates memory:
660         delete [] vertices;
661         delete [] normals;
662         delete [] VIndices;
663         delete [] NIndices;
664
665         // Fix for degenerated triangles
666         // A degenerate triangle is a triangle such that
667         // 1) A and B are in the same position in the 3D space; or
668         // 2) the distance between point P and line segment AB is zero.
669         // Only those degenerate triangles in the second form are resolved here
670         // by adding a small offset to P, whereas those in the first form are
671         // addressed later in WShape::MakeFace().
672         vector<detri_t> detriList;
673         Vec3r zero(0.0, 0.0, 0.0);
674         unsigned vi0, vi1, vi2;
675         for (i = 0; i < viSize; i += 3) {
676                 detri_t detri;
677                 vi0 = cleanVIndices[i];
678                 vi1 = cleanVIndices[i + 1];
679                 vi2 = cleanVIndices[i + 2];
680                 Vec3r v0(cleanVertices[vi0], cleanVertices[vi0 + 1], cleanVertices[vi0 + 2]);
681                 Vec3r v1(cleanVertices[vi1], cleanVertices[vi1 + 1], cleanVertices[vi1 + 2]);
682                 Vec3r v2(cleanVertices[vi2], cleanVertices[vi2 + 1], cleanVertices[vi2 + 2]);
683                 if (v0 == v1 || v0 == v2 || v1 == v2) {
684                         continue; // do nothing for now
685                 }
686                 else if (GeomUtils::distPointSegment<Vec3r>(v0, v1, v2) < 1.0e-6) {
687                         detri.viP = vi0;
688                         detri.viA = vi1;
689                         detri.viB = vi2;
690                 }
691                 else if (GeomUtils::distPointSegment<Vec3r>(v1, v0, v2) < 1.0e-6) {
692                         detri.viP = vi1;
693                         detri.viA = vi0;
694                         detri.viB = vi2;
695                 }
696                 else if (GeomUtils::distPointSegment<Vec3r>(v2, v0, v1) < 1.0e-6) {
697                         detri.viP = vi2;
698                         detri.viA = vi0;
699                         detri.viB = vi1;
700                 }
701                 else {
702                         continue;
703                 }
704
705                 detri.v = zero;
706                 detri.n = 0;
707                 for (unsigned int j = 0; j < viSize; j += 3) {
708                         if (i == j)
709                                 continue;
710                         vi0 = cleanVIndices[j];
711                         vi1 = cleanVIndices[j + 1];
712                         vi2 = cleanVIndices[j + 2];
713                         Vec3r v0(cleanVertices[vi0], cleanVertices[vi0 + 1], cleanVertices[vi0 + 2]);
714                         Vec3r v1(cleanVertices[vi1], cleanVertices[vi1 + 1], cleanVertices[vi1 + 2]);
715                         Vec3r v2(cleanVertices[vi2], cleanVertices[vi2 + 1], cleanVertices[vi2 + 2]);
716                         if (detri.viP == vi0 && (detri.viA == vi1 || detri.viB == vi1)) {
717                                 detri.v += (v2 - v0);
718                                 detri.n++;
719                         }
720                         else if (detri.viP == vi0 && (detri.viA == vi2 || detri.viB == vi2)) {
721                                 detri.v += (v1 - v0);
722                                 detri.n++;
723                         }
724                         else if (detri.viP == vi1 && (detri.viA == vi0 || detri.viB == vi0)) {
725                                 detri.v += (v2 - v1);
726                                 detri.n++;
727                         }
728                         else if (detri.viP == vi1 && (detri.viA == vi2 || detri.viB == vi2)) {
729                                 detri.v += (v0 - v1);
730                                 detri.n++;
731                         }
732                         else if (detri.viP == vi2 && (detri.viA == vi0 || detri.viB == vi0)) {
733                                 detri.v += (v1 - v2);
734                                 detri.n++;
735                         }
736                         else if (detri.viP == vi2 && (detri.viA == vi1 || detri.viB == vi1)) {
737                                 detri.v += (v0 - v2);
738                                 detri.n++;
739                         }
740                 }
741                 if (detri.n > 0) {
742                         detri.v.normalizeSafe();
743                 }
744                 detriList.push_back(detri);
745         }
746
747         if (detriList.size() > 0) {
748                 vector<detri_t>::iterator v;
749                 for (v = detriList.begin(); v != detriList.end(); v++) {
750                         detri_t detri = (*v);
751                         if (detri.n == 0) {
752                                 cleanVertices[detri.viP]   = cleanVertices[detri.viA];
753                                 cleanVertices[detri.viP + 1] = cleanVertices[detri.viA + 1];
754                                 cleanVertices[detri.viP + 2] = cleanVertices[detri.viA + 2];
755                         }
756                         else if (detri.v.norm() > 0.0) {
757                                 cleanVertices[detri.viP]   += 1.0e-5 * detri.v.x();
758                                 cleanVertices[detri.viP + 1] += 1.0e-5 * detri.v.y();
759                                 cleanVertices[detri.viP + 2] += 1.0e-5 * detri.v.z();
760                         }
761                 }
762                 if (G.debug & G_DEBUG_FREESTYLE) {
763                         printf("Warning: Object %s contains %lu degenerated triangle%s (strokes may be incorrect)\n",
764                                name, (long unsigned int)detriList.size(), (detriList.size() > 1) ? "s" : "");
765                 }
766         }
767
768         // Create the IndexedFaceSet with the retrieved attributes
769         IndexedFaceSet *rep;
770         rep = new IndexedFaceSet(cleanVertices, cvSize, cleanNormals, cnSize, marray, meshFrsMaterials.size(), 0, 0,
771                                  numFaces, numVertexPerFaces, faceStyle, faceEdgeMarks, cleanVIndices, viSize,
772                                  cleanNIndices, niSize, MIndices, viSize, 0, 0, 0);
773         // sets the id of the rep
774         rep->setId(Id(id, 0));
775         rep->setName(obi->ob->id.name + 2);
776
777         const BBox<Vec3r> bbox = BBox<Vec3r>(Vec3r(ls.minBBox[0], ls.minBBox[1], ls.minBBox[2]),
778                                              Vec3r(ls.maxBBox[0], ls.maxBBox[1], ls.maxBBox[2]));
779         rep->setBBox(bbox);
780         shape->AddRep(rep);
781
782         Matrix44r meshMat = Matrix44r::identity();
783         currentMesh->setMatrix(meshMat);
784         currentMesh->Translate(0, 0, 0);
785
786         currentMesh->AddChild(shape);
787         _Scene->AddChild(currentMesh);
788 }
789
790 } /* namespace Freestyle */