Merge branch 'blender2.7'
[blender.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 #include <sstream>
32
33 namespace Freestyle {
34
35 BlenderFileLoader::BlenderFileLoader(Render *re, ViewLayer *view_layer)
36 {
37         _re = re;
38         _view_layer = view_layer;
39         _Scene = NULL;
40         _numFacesRead = 0;
41 #if 0
42         _minEdgeSize = DBL_MAX;
43 #endif
44         _smooth = (view_layer->freestyle_config.flags & FREESTYLE_FACE_SMOOTHNESS_FLAG) != 0;
45         _pRenderMonitor = NULL;
46 }
47
48 BlenderFileLoader::~BlenderFileLoader()
49 {
50         _Scene = NULL;
51 }
52
53 NodeGroup *BlenderFileLoader::Load()
54 {
55         if (G.debug & G_DEBUG_FREESTYLE) {
56                 cout << "\n===  Importing triangular meshes into Blender  ===" << endl;
57         }
58
59         // creation of the scene root node
60         _Scene = new NodeGroup;
61
62         _viewplane_left =   _re->viewplane.xmin;
63         _viewplane_right =  _re->viewplane.xmax;
64         _viewplane_bottom = _re->viewplane.ymin;
65         _viewplane_top =    _re->viewplane.ymax;
66
67         if (_re->clipsta < 0.f) {
68                 // Adjust clipping start/end and set up a Z offset when the viewport preview
69                 // is used with the orthographic view.  In this case, _re->clipsta is negative,
70                 // while Freestyle assumes that imported mesh data are in the camera coordinate
71                 // system with the view point located at origin [bug #36009].
72                 _z_near = -0.001f;
73                 _z_offset = _re->clipsta + _z_near;
74                 _z_far = -_re->clipend + _z_offset;
75         }
76         else {
77                 _z_near = -_re->clipsta;
78                 _z_far = -_re->clipend;
79                 _z_offset = 0.f;
80         }
81
82         ViewLayer *view_layer = (ViewLayer*)BLI_findstring(&_re->scene->view_layers, _view_layer->name, offsetof(ViewLayer, name));
83         Depsgraph *depsgraph = DEG_graph_new(_re->scene, view_layer, DAG_EVAL_RENDER);
84
85         BKE_scene_graph_update_tagged(depsgraph, _re->main);
86
87 #if 0
88         if (G.debug & G_DEBUG_FREESTYLE) {
89                 cout << "Frustum: l " << _viewplane_left << " r " << _viewplane_right
90                      << " b " << _viewplane_bottom << " t " << _viewplane_top
91                      << " n " << _z_near << " f " << _z_far << endl;
92         }
93 #endif
94
95         int id = 0;
96
97         DEG_OBJECT_ITER_BEGIN(
98                 depsgraph, ob,
99                 DEG_ITER_OBJECT_FLAG_LINKED_DIRECTLY |
100                 DEG_ITER_OBJECT_FLAG_LINKED_VIA_SET |
101                 DEG_ITER_OBJECT_FLAG_VISIBLE |
102                 DEG_ITER_OBJECT_FLAG_DUPLI)
103         {
104                 if (_pRenderMonitor && _pRenderMonitor->testBreak()) {
105                         break;
106                 }
107
108                 bool apply_modifiers = false;
109                 bool calc_undeformed = false;
110                 Mesh *mesh = BKE_mesh_new_from_object(depsgraph,
111                                                       _re->main,
112                                                       _re->scene,
113                                                       ob,
114                                                       apply_modifiers,
115                                                       calc_undeformed);
116
117                 if (mesh) {
118                         insertShapeNode(ob, mesh, ++id);
119                         BKE_id_free_ex(_re->main, &mesh->id, LIB_ID_FREE_NO_UI_USER, true);
120                 }
121         }
122         DEG_OBJECT_ITER_END;
123
124         DEG_graph_free(depsgraph);
125
126         // Return the built scene.
127         return _Scene;
128 }
129
130 #define CLIPPED_BY_NEAR -1
131 #define NOT_CLIPPED      0
132 #define CLIPPED_BY_FAR   1
133
134 // check if each vertex of a triangle (V1, V2, V3) is clipped by the near/far plane
135 // and calculate the number of triangles to be generated by clipping
136 int BlenderFileLoader::countClippedFaces(float v1[3], float v2[3], float v3[3], int clip[3])
137 {
138         float *v[3];
139         int numClipped, sum, numTris = 0;
140
141         v[0] = v1;
142         v[1] = v2;
143         v[2] = v3;
144         numClipped = sum = 0;
145         for (int i = 0; i < 3; i++) {
146                 if (v[i][2] > _z_near) {
147                         clip[i] = CLIPPED_BY_NEAR;
148                         numClipped++;
149                 }
150                 else if (v[i][2] < _z_far) {
151                         clip[i] = CLIPPED_BY_FAR;
152                         numClipped++;
153                 }
154                 else {
155                         clip[i] = NOT_CLIPPED;
156                 }
157 #if 0
158                 if (G.debug & G_DEBUG_FREESTYLE) {
159                         printf("%d %s\n", i, (clip[i] == NOT_CLIPPED) ? "not" : (clip[i] == CLIPPED_BY_NEAR) ? "near" : "far");
160                 }
161 #endif
162                 sum += clip[i];
163         }
164         switch (numClipped) {
165                 case 0:
166                         numTris = 1; // triangle
167                         break;
168                 case 1:
169                         numTris = 2; // tetragon
170                         break;
171                 case 2:
172                         if (sum == 0)
173                                 numTris = 3; // pentagon
174                         else
175                                 numTris = 1; // triangle
176                         break;
177                 case 3:
178                         if (sum == 3 || sum == -3)
179                                 numTris = 0;
180                         else
181                                 numTris = 2; // tetragon
182                         break;
183         }
184         return numTris;
185 }
186
187 // find the intersection point C between the line segment from V1 to V2 and
188 // a clipping plane at depth Z (i.e., the Z component of C is known, while
189 // the X and Y components are unknown).
190 void BlenderFileLoader::clipLine(float v1[3], float v2[3], float c[3], float z)
191 {
192         // Order v1 and v2 by Z values to make sure that clipLine(P, Q, c, z)
193         // and clipLine(Q, P, c, z) gives exactly the same numerical result.
194         float *p, *q;
195         if (v1[2] < v2[2]) {
196                 p = v1;
197                 q = v2;
198         }
199         else {
200                 p = v2;
201                 q = v1;
202         }
203         double d[3];
204         for (int i = 0; i < 3; i++)
205                 d[i] = q[i] - p[i];
206         double t = (z - p[2]) / d[2];
207         c[0] = p[0] + t * d[0];
208         c[1] = p[1] + t * d[1];
209         c[2] = z;
210 }
211
212 // clip the triangle (V1, V2, V3) by the near and far clipping plane and
213 // obtain a set of vertices after the clipping.  The number of vertices
214 // is at most 5.
215 void BlenderFileLoader::clipTriangle(int numTris, float triCoords[][3], float v1[3], float v2[3], float v3[3],
216                                      float triNormals[][3], float n1[3], float n2[3], float n3[3],
217                                      bool edgeMarks[], bool em1, bool em2, bool em3, int clip[3])
218 {
219         float *v[3], *n[3];
220         bool em[3];
221         int i, j, k;
222
223         v[0] = v1; n[0] = n1;
224         v[1] = v2; n[1] = n2;
225         v[2] = v3; n[2] = n3;
226         em[0] = em1; /* edge mark of the edge between v1 and v2 */
227         em[1] = em2; /* edge mark of the edge between v2 and v3 */
228         em[2] = em3; /* edge mark of the edge between v3 and v1 */
229         k = 0;
230         for (i = 0; i < 3; i++) {
231                 j = (i + 1) % 3;
232                 if (clip[i] == NOT_CLIPPED) {
233                         copy_v3_v3(triCoords[k], v[i]);
234                         copy_v3_v3(triNormals[k], n[i]);
235                         edgeMarks[k] = em[i];
236                         k++;
237                         if (clip[j] != NOT_CLIPPED) {
238                                 clipLine(v[i], v[j], triCoords[k], (clip[j] == CLIPPED_BY_NEAR) ? _z_near : _z_far);
239                                 copy_v3_v3(triNormals[k], n[j]);
240                                 edgeMarks[k] = false;
241                                 k++;
242                         }
243                 }
244                 else if (clip[i] != clip[j]) {
245                         if (clip[j] == NOT_CLIPPED) {
246                                 clipLine(v[i], v[j], triCoords[k], (clip[i] == CLIPPED_BY_NEAR) ? _z_near : _z_far);
247                                 copy_v3_v3(triNormals[k], n[i]);
248                                 edgeMarks[k] = em[i];
249                                 k++;
250                         }
251                         else {
252                                 clipLine(v[i], v[j], triCoords[k], (clip[i] == CLIPPED_BY_NEAR) ? _z_near : _z_far);
253                                 copy_v3_v3(triNormals[k], n[i]);
254                                 edgeMarks[k] = em[i];
255                                 k++;
256                                 clipLine(v[i], v[j], triCoords[k], (clip[j] == CLIPPED_BY_NEAR) ? _z_near : _z_far);
257                                 copy_v3_v3(triNormals[k], n[j]);
258                                 edgeMarks[k] = false;
259                                 k++;
260                         }
261                 }
262         }
263         BLI_assert(k == 2 + numTris);
264         (void)numTris;  /* Ignored in release builds. */
265 }
266
267 void BlenderFileLoader::addTriangle(struct LoaderState *ls, float v1[3], float v2[3], float v3[3],
268                                     float n1[3], float n2[3], float n3[3],
269                                     bool fm, bool em1, bool em2, bool em3)
270 {
271         float *fv[3], *fn[3];
272 #if 0
273         float len;
274 #endif
275         unsigned int i, j;
276         IndexedFaceSet::FaceEdgeMark marks = 0;
277
278         // initialize the bounding box by the first vertex
279         if (ls->currentIndex == 0) {
280                 copy_v3_v3(ls->minBBox, v1);
281                 copy_v3_v3(ls->maxBBox, v1);
282         }
283
284         fv[0] = v1; fn[0] = n1;
285         fv[1] = v2; fn[1] = n2;
286         fv[2] = v3; fn[2] = n3;
287         for (i = 0; i < 3; i++) {
288
289                 copy_v3_v3(ls->pv, fv[i]);
290                 copy_v3_v3(ls->pn, fn[i]);
291
292                 // update the bounding box
293                 for (j = 0; j < 3; j++) {
294                         if (ls->minBBox[j] > ls->pv[j])
295                                 ls->minBBox[j] = ls->pv[j];
296
297                         if (ls->maxBBox[j] < ls->pv[j])
298                                 ls->maxBBox[j] = ls->pv[j];
299                 }
300
301 #if 0
302                 len = len_v3v3(fv[i], fv[(i + 1) % 3]);
303                 if (_minEdgeSize > len)
304                         _minEdgeSize = len;
305 #endif
306
307                 *ls->pvi = ls->currentIndex;
308                 *ls->pni = ls->currentIndex;
309                 *ls->pmi = ls->currentMIndex;
310
311                 ls->currentIndex += 3;
312                 ls->pv += 3;
313                 ls->pn += 3;
314
315                 ls->pvi++;
316                 ls->pni++;
317                 ls->pmi++;
318         }
319
320         if (fm)
321                 marks |= IndexedFaceSet::FACE_MARK;
322         if (em1)
323                 marks |= IndexedFaceSet::EDGE_MARK_V1V2;
324         if (em2)
325                 marks |= IndexedFaceSet::EDGE_MARK_V2V3;
326         if (em3)
327                 marks |= IndexedFaceSet::EDGE_MARK_V3V1;
328         *(ls->pm++) = marks;
329 }
330
331 // With A, B and P indicating the three vertices of a given triangle, returns:
332 // 1 if points A and B are in the same position in the 3D space;
333 // 2 if the distance between point P and line segment AB is zero; and
334 // zero otherwise.
335 int BlenderFileLoader::testDegenerateTriangle(float v1[3], float v2[3], float v3[3])
336 {
337         const float eps = 1.0e-6;
338         const float eps_sq = eps * eps;
339
340 #if 0
341         float area = area_tri_v3(v1, v2, v3);
342         bool verbose = (area < 1.0e-6);
343 #endif
344
345         if (equals_v3v3(v1, v2) || equals_v3v3(v2, v3) || equals_v3v3(v1, v3)) {
346 #if 0
347                 if (verbose && G.debug & G_DEBUG_FREESTYLE) {
348                         printf("BlenderFileLoader::testDegenerateTriangle = 1\n");
349                 }
350 #endif
351                 return 1;
352         }
353         if (dist_squared_to_line_segment_v3(v1, v2, v3) < eps_sq ||
354             dist_squared_to_line_segment_v3(v2, v1, v3) < eps_sq ||
355             dist_squared_to_line_segment_v3(v3, v1, v2) < eps_sq)
356         {
357 #if 0
358                 if (verbose && G.debug & G_DEBUG_FREESTYLE) {
359                         printf("BlenderFileLoader::testDegenerateTriangle = 2\n");
360                 }
361 #endif
362                 return 2;
363         }
364 #if 0
365         if (verbose && G.debug & G_DEBUG_FREESTYLE) {
366                 printf("BlenderFileLoader::testDegenerateTriangle = 0\n");
367         }
368 #endif
369         return 0;
370 }
371
372 static bool testEdgeMark(Mesh *me, FreestyleEdge *fed, const MLoopTri *lt, int i)
373 {
374         MLoop *mloop = &me->mloop[lt->tri[i]];
375         MLoop *mloop_next = &me->mloop[lt->tri[(i+1)%3]];
376         MEdge *medge = &me->medge[mloop->e];
377
378         if (!ELEM(mloop_next->v, medge->v1, medge->v2)) {
379                 /* Not an edge in the original mesh before triangulation. */
380                 return false;
381         }
382
383         return (fed[mloop->e].flag & FREESTYLE_EDGE_MARK) != 0;
384 }
385
386 void BlenderFileLoader::insertShapeNode(Object *ob, Mesh *me, int id)
387 {
388         char *name = ob->id.name + 2;
389
390         // Compute loop triangles
391         int tottri = poly_to_tri_count(me->totpoly, me->totloop);
392         MLoopTri *mlooptri = (MLoopTri*)MEM_malloc_arrayN(tottri, sizeof(*mlooptri), __func__);
393         BKE_mesh_recalc_looptri(
394                 me->mloop, me->mpoly,
395                 me->mvert,
396                 me->totloop, me->totpoly,
397                 mlooptri);
398
399         // Compute loop normals
400         BKE_mesh_calc_normals_split(me);
401         float (*lnors)[3] = NULL;
402
403         if (CustomData_has_layer(&me->ldata, CD_NORMAL)) {
404                 lnors = (float(*)[3])CustomData_get_layer(&me->ldata, CD_NORMAL);
405         }
406
407         // Get other mesh data
408         MVert *mvert = me->mvert;
409         MLoop *mloop = me->mloop;
410         MPoly *mpoly = me->mpoly;
411         FreestyleEdge *fed = (FreestyleEdge*)CustomData_get_layer(&me->edata, CD_FREESTYLE_EDGE);
412         FreestyleFace *ffa = (FreestyleFace*)CustomData_get_layer(&me->pdata, CD_FREESTYLE_FACE);
413
414         // Compute matrix including camera transform
415         float obmat[4][4], nmat[4][4];
416         mul_m4_m4m4(obmat, _re->viewmat, ob->obmat);
417         invert_m4_m4(nmat, obmat);
418         transpose_m4(nmat);
419
420         // We count the number of triangles after the clipping by the near and far view
421         // planes is applied (Note: mesh vertices are in the camera coordinate system).
422         unsigned numFaces = 0;
423         float v1[3], v2[3], v3[3];
424         float n1[3], n2[3], n3[3], facenormal[3];
425         int clip[3];
426         for (int a = 0; a < tottri; a++) {
427                 const MLoopTri *lt = &mlooptri[a];
428
429                 copy_v3_v3(v1, mvert[mloop[lt->tri[0]].v].co);
430                 copy_v3_v3(v2, mvert[mloop[lt->tri[1]].v].co);
431                 copy_v3_v3(v3, mvert[mloop[lt->tri[2]].v].co);
432
433                 mul_m4_v3(obmat, v1);
434                 mul_m4_v3(obmat, v2);
435                 mul_m4_v3(obmat, v3);
436
437                 v1[2] += _z_offset;
438                 v2[2] += _z_offset;
439                 v3[2] += _z_offset;
440
441                 numFaces += countClippedFaces(v1, v2, v3, clip);
442         }
443 #if 0
444         if (G.debug & G_DEBUG_FREESTYLE) {
445                 cout << "numFaces " << numFaces << endl;
446         }
447 #endif
448         if (numFaces == 0) {
449                 MEM_freeN(mlooptri);
450                 return;
451         }
452
453         // We allocate memory for the meshes to be imported
454         NodeGroup *currentMesh = new NodeGroup;
455         NodeShape *shape = new NodeShape;
456
457         unsigned vSize = 3 * 3 * numFaces;
458         float *vertices = new float[vSize];
459         unsigned nSize = vSize;
460         float *normals = new float[nSize];
461         unsigned *numVertexPerFaces = new unsigned[numFaces];
462         vector<Material *> meshMaterials;
463         vector<FrsMaterial> meshFrsMaterials;
464
465         IndexedFaceSet::TRIANGLES_STYLE *faceStyle = new IndexedFaceSet::TRIANGLES_STYLE[numFaces];
466         unsigned i;
467         for (i = 0; i <numFaces; i++) {
468                 faceStyle[i] = IndexedFaceSet::TRIANGLES;
469                 numVertexPerFaces[i] = 3;
470         }
471
472         IndexedFaceSet::FaceEdgeMark *faceEdgeMarks = new IndexedFaceSet::FaceEdgeMark[numFaces];
473
474         unsigned viSize = 3 * numFaces;
475         unsigned *VIndices = new unsigned[viSize];
476         unsigned niSize = viSize;
477         unsigned *NIndices = new unsigned[niSize];
478         unsigned *MIndices = new unsigned[viSize]; // Material Indices
479
480         struct LoaderState ls;
481         ls.pv = vertices;
482         ls.pn = normals;
483         ls.pm = faceEdgeMarks;
484         ls.pvi = VIndices;
485         ls.pni = NIndices;
486         ls.pmi = MIndices;
487         ls.currentIndex = 0;
488         ls.currentMIndex = 0;
489
490         FrsMaterial tmpMat;
491
492         // We parse the vlak nodes again and import meshes while applying the clipping
493         // by the near and far view planes.
494         for (int a = 0; a < tottri; a++) {
495                 const MLoopTri *lt = &mlooptri[a];
496                 const MPoly *mp = &mpoly[lt->poly];
497                 Material *mat = give_current_material(ob, mp->mat_nr + 1);
498
499                 copy_v3_v3(v1, mvert[mloop[lt->tri[0]].v].co);
500                 copy_v3_v3(v2, mvert[mloop[lt->tri[1]].v].co);
501                 copy_v3_v3(v3, mvert[mloop[lt->tri[2]].v].co);
502
503                 mul_m4_v3(obmat, v1);
504                 mul_m4_v3(obmat, v2);
505                 mul_m4_v3(obmat, v3);
506
507                 v1[2] += _z_offset;
508                 v2[2] += _z_offset;
509                 v3[2] += _z_offset;
510
511                 if (_smooth && (mp->flag & ME_SMOOTH) && lnors) {
512                         copy_v3_v3(n1, lnors[lt->tri[0]]);
513                         copy_v3_v3(n2, lnors[lt->tri[1]]);
514                         copy_v3_v3(n3, lnors[lt->tri[2]]);
515
516                         mul_mat3_m4_v3(nmat, n1);
517                         mul_mat3_m4_v3(nmat, n2);
518                         mul_mat3_m4_v3(nmat, n3);
519
520                         normalize_v3(n1);
521                         normalize_v3(n2);
522                         normalize_v3(n3);
523                 }
524                 else {
525                         normal_tri_v3(facenormal, v3, v2, v1);
526
527                         copy_v3_v3(n1, facenormal);
528                         copy_v3_v3(n2, facenormal);
529                         copy_v3_v3(n3, facenormal);
530                 }
531
532                 unsigned int numTris = countClippedFaces(v1, v2, v3, clip);
533                 if (numTris == 0)
534                         continue;
535
536                 bool fm = (ffa) ? (ffa[lt->poly].flag & FREESTYLE_FACE_MARK) != 0 : false;
537                 bool em1 = false, em2 = false, em3 = false;
538
539                 if (fed) {
540                         em1 = testEdgeMark(me, fed, lt, 0);
541                         em2 = testEdgeMark(me, fed, lt, 1);
542                         em3 = testEdgeMark(me, fed, lt, 2);
543                 }
544
545                 if (mat) {
546                         tmpMat.setLine(mat->line_col[0], mat->line_col[1], mat->line_col[2], mat->line_col[3]);
547                         tmpMat.setDiffuse(mat->r, mat->g, mat->b, 1.0f);
548                         tmpMat.setSpecular(mat->specr, mat->specg, mat->specb, 1.0f);
549                         tmpMat.setShininess(128.f);
550                         tmpMat.setPriority(mat->line_priority);
551                 }
552
553                 if (meshMaterials.empty()) {
554                         meshMaterials.push_back(mat);
555                         meshFrsMaterials.push_back(tmpMat);
556                         shape->setFrsMaterial(tmpMat);
557                 }
558                 else {
559                         // find if the Blender material is already in the list
560                         unsigned int i = 0;
561                         bool found = false;
562
563                         for (vector<Material *>::iterator it = meshMaterials.begin(), itend = meshMaterials.end();
564                              it != itend;
565                              it++, i++)
566                         {
567                                 if (*it == mat) {
568                                         ls.currentMIndex = i;
569                                         found = true;
570                                         break;
571                                 }
572                         }
573
574                         if (!found) {
575                                 meshMaterials.push_back(mat);
576                                 meshFrsMaterials.push_back(tmpMat);
577                                 ls.currentMIndex = meshFrsMaterials.size() - 1;
578                         }
579                 }
580
581                 float triCoords[5][3], triNormals[5][3];
582                 bool edgeMarks[5]; // edgeMarks[i] is for the edge between i-th and (i+1)-th vertices
583
584                 clipTriangle(numTris, triCoords, v1, v2, v3, triNormals, n1, n2, n3,
585                              edgeMarks, em1, em2, em3, clip);
586                 for (i = 0; i < numTris; i++) {
587                         addTriangle(&ls, triCoords[0], triCoords[i + 1], triCoords[i + 2],
588                                     triNormals[0], triNormals[i + 1], triNormals[i + 2],
589                                     fm, (i == 0) ? edgeMarks[0] : false, edgeMarks[i + 1],
590                                     (i == numTris - 1) ? edgeMarks[i + 2] : false);
591                         _numFacesRead++;
592                 }
593         }
594
595         MEM_freeN(mlooptri);
596
597         // We might have several times the same vertex. We want a clean
598         // shape with no real-vertex. Here, we are making a cleaning pass.
599         float *cleanVertices = NULL;
600         unsigned int cvSize;
601         unsigned int *cleanVIndices = NULL;
602
603         GeomCleaner::CleanIndexedVertexArray(vertices, vSize, VIndices, viSize, &cleanVertices, &cvSize, &cleanVIndices);
604
605         float *cleanNormals = NULL;
606         unsigned int cnSize;
607         unsigned int *cleanNIndices = NULL;
608
609         GeomCleaner::CleanIndexedVertexArray(normals, nSize, NIndices, niSize, &cleanNormals, &cnSize, &cleanNIndices);
610
611         // format materials array
612         FrsMaterial **marray = new FrsMaterial *[meshFrsMaterials.size()];
613         unsigned int mindex = 0;
614         for (vector<FrsMaterial>::iterator m = meshFrsMaterials.begin(), mend = meshFrsMaterials.end(); m != mend; ++m) {
615                 marray[mindex] = new FrsMaterial(*m);
616                 ++mindex;
617         }
618
619         // deallocates memory:
620         delete [] vertices;
621         delete [] normals;
622         delete [] VIndices;
623         delete [] NIndices;
624
625         // Fix for degenerated triangles
626         // A degenerate triangle is a triangle such that
627         // 1) A and B are in the same position in the 3D space; or
628         // 2) the distance between point P and line segment AB is zero.
629         // Only those degenerate triangles in the second form are resolved here
630         // by adding a small offset to P, whereas those in the first form are
631         // addressed later in WShape::MakeFace().
632         vector<detri_t> detriList;
633         Vec3r zero(0.0, 0.0, 0.0);
634         unsigned vi0, vi1, vi2;
635         for (i = 0; i < viSize; i += 3) {
636                 detri_t detri;
637                 vi0 = cleanVIndices[i];
638                 vi1 = cleanVIndices[i + 1];
639                 vi2 = cleanVIndices[i + 2];
640                 Vec3r v0(cleanVertices[vi0], cleanVertices[vi0 + 1], cleanVertices[vi0 + 2]);
641                 Vec3r v1(cleanVertices[vi1], cleanVertices[vi1 + 1], cleanVertices[vi1 + 2]);
642                 Vec3r v2(cleanVertices[vi2], cleanVertices[vi2 + 1], cleanVertices[vi2 + 2]);
643                 if (v0 == v1 || v0 == v2 || v1 == v2) {
644                         continue; // do nothing for now
645                 }
646                 else if (GeomUtils::distPointSegment<Vec3r>(v0, v1, v2) < 1.0e-6) {
647                         detri.viP = vi0;
648                         detri.viA = vi1;
649                         detri.viB = vi2;
650                 }
651                 else if (GeomUtils::distPointSegment<Vec3r>(v1, v0, v2) < 1.0e-6) {
652                         detri.viP = vi1;
653                         detri.viA = vi0;
654                         detri.viB = vi2;
655                 }
656                 else if (GeomUtils::distPointSegment<Vec3r>(v2, v0, v1) < 1.0e-6) {
657                         detri.viP = vi2;
658                         detri.viA = vi0;
659                         detri.viB = vi1;
660                 }
661                 else {
662                         continue;
663                 }
664
665                 detri.v = zero;
666                 detri.n = 0;
667                 for (unsigned int j = 0; j < viSize; j += 3) {
668                         if (i == j)
669                                 continue;
670                         vi0 = cleanVIndices[j];
671                         vi1 = cleanVIndices[j + 1];
672                         vi2 = cleanVIndices[j + 2];
673                         Vec3r v0(cleanVertices[vi0], cleanVertices[vi0 + 1], cleanVertices[vi0 + 2]);
674                         Vec3r v1(cleanVertices[vi1], cleanVertices[vi1 + 1], cleanVertices[vi1 + 2]);
675                         Vec3r v2(cleanVertices[vi2], cleanVertices[vi2 + 1], cleanVertices[vi2 + 2]);
676                         if (detri.viP == vi0 && (detri.viA == vi1 || detri.viB == vi1)) {
677                                 detri.v += (v2 - v0);
678                                 detri.n++;
679                         }
680                         else if (detri.viP == vi0 && (detri.viA == vi2 || detri.viB == vi2)) {
681                                 detri.v += (v1 - v0);
682                                 detri.n++;
683                         }
684                         else if (detri.viP == vi1 && (detri.viA == vi0 || detri.viB == vi0)) {
685                                 detri.v += (v2 - v1);
686                                 detri.n++;
687                         }
688                         else if (detri.viP == vi1 && (detri.viA == vi2 || detri.viB == vi2)) {
689                                 detri.v += (v0 - v1);
690                                 detri.n++;
691                         }
692                         else if (detri.viP == vi2 && (detri.viA == vi0 || detri.viB == vi0)) {
693                                 detri.v += (v1 - v2);
694                                 detri.n++;
695                         }
696                         else if (detri.viP == vi2 && (detri.viA == vi1 || detri.viB == vi1)) {
697                                 detri.v += (v0 - v2);
698                                 detri.n++;
699                         }
700                 }
701                 if (detri.n > 0) {
702                         detri.v.normalizeSafe();
703                 }
704                 detriList.push_back(detri);
705         }
706
707         if (detriList.size() > 0) {
708                 vector<detri_t>::iterator v;
709                 for (v = detriList.begin(); v != detriList.end(); v++) {
710                         detri_t detri = (*v);
711                         if (detri.n == 0) {
712                                 cleanVertices[detri.viP]     = cleanVertices[detri.viA];
713                                 cleanVertices[detri.viP + 1] = cleanVertices[detri.viA + 1];
714                                 cleanVertices[detri.viP + 2] = cleanVertices[detri.viA + 2];
715                         }
716                         else if (detri.v.norm() > 0.0) {
717                                 cleanVertices[detri.viP]     += 1.0e-5 * detri.v.x();
718                                 cleanVertices[detri.viP + 1] += 1.0e-5 * detri.v.y();
719                                 cleanVertices[detri.viP + 2] += 1.0e-5 * detri.v.z();
720                         }
721                 }
722                 if (G.debug & G_DEBUG_FREESTYLE) {
723                         printf("Warning: Object %s contains %lu degenerated triangle%s (strokes may be incorrect)\n",
724                                name, (long unsigned int)detriList.size(), (detriList.size() > 1) ? "s" : "");
725                 }
726         }
727
728         // Create the IndexedFaceSet with the retrieved attributes
729         IndexedFaceSet *rep;
730         rep = new IndexedFaceSet(cleanVertices, cvSize, cleanNormals, cnSize, marray, meshFrsMaterials.size(), 0, 0,
731                                  numFaces, numVertexPerFaces, faceStyle, faceEdgeMarks, cleanVIndices, viSize,
732                                  cleanNIndices, niSize, MIndices, viSize, 0, 0, 0);
733         // sets the id of the rep
734         rep->setId(Id(id, 0));
735         rep->setName(ob->id.name + 2);
736         rep->setLibraryPath(ob->id.lib ? ob->id.lib->name : "");
737
738         const BBox<Vec3r> bbox = BBox<Vec3r>(Vec3r(ls.minBBox[0], ls.minBBox[1], ls.minBBox[2]),
739                                              Vec3r(ls.maxBBox[0], ls.maxBBox[1], ls.maxBBox[2]));
740         rep->setBBox(bbox);
741         shape->AddRep(rep);
742
743         currentMesh->AddChild(shape);
744         _Scene->AddChild(currentMesh);
745 }
746
747 } /* namespace Freestyle */