0031501: Foundation Classes, Message_Printer - remove theToPutEndl argument -- use...
[occt.git] / src / RWObj / RWObj_Reader.cxx
1 // Author: Kirill Gavrilov
2 // Copyright (c) 2017-2019 OPEN CASCADE SAS
3 //
4 // This file is part of Open CASCADE Technology software library.
5 //
6 // This library is free software; you can redistribute it and/or modify it under
7 // the terms of the GNU Lesser General Public License version 2.1 as published
8 // by the Free Software Foundation, with special exception defined in the file
9 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
10 // distribution for complete text of the license and disclaimer of any warranty.
11 //
12 // Alternatively, this file may be used under the terms of Open CASCADE
13 // commercial license or contractual agreement.
14
15 #include <RWObj_Reader.hxx>
16
17 #include <RWObj_MtlReader.hxx>
18
19 #include <BRepMesh_DataStructureOfDelaun.hxx>
20 #include <BRepMesh_Delaun.hxx>
21 #include <gp_XY.hxx>
22 #include <Message.hxx>
23 #include <Message_Messenger.hxx>
24 #include <Message_ProgressSentry.hxx>
25 #include <NCollection_IncAllocator.hxx>
26 #include <OSD_OpenFile.hxx>
27 #include <OSD_Path.hxx>
28 #include <OSD_Timer.hxx>
29 #include <Precision.hxx>
30 #include <Standard_CLocaleSentry.hxx>
31 #include <Standard_ReadLineBuffer.hxx>
32
33 #include <algorithm>
34 #include <limits>
35
36 #if defined(_WIN32)
37   #define ftell64(a)     _ftelli64(a)
38   #define fseek64(a,b,c) _fseeki64(a,b,c)
39 #else
40   #define ftell64(a)     ftello(a)
41   #define fseek64(a,b,c) fseeko(a,b,c)
42 #endif
43
44 IMPLEMENT_STANDARD_RTTIEXT(RWObj_Reader, Standard_Transient)
45
46 namespace
47 {
48   // The length of buffer to read (in bytes)
49   static const size_t THE_BUFFER_SIZE = 4 * 1024;
50
51   //! Simple wrapper.
52   struct RWObj_ReaderFile
53   {
54     FILE*   File;
55     int64_t FileLen;
56
57     //! Constructor opening the file.
58     RWObj_ReaderFile (const TCollection_AsciiString& theFile)
59     : File (OSD_OpenFile (theFile.ToCString(), "rb")),
60       FileLen (0)
61     {
62       if (this->File != NULL)
63       {
64         // determine length of file
65         ::fseek64 (this->File, 0, SEEK_END);
66         FileLen = ::ftell64 (this->File);
67         ::fseek64 (this->File, 0, SEEK_SET);
68       }
69     }
70
71     //! Destructor closing the file.
72     ~RWObj_ReaderFile()
73     {
74       if (File != NULL)
75       {
76         ::fclose (File);
77       }
78     }
79   };
80
81   //! Return TRUE if given polygon has clockwise node order.
82   static bool isClockwisePolygon (const Handle(BRepMesh_DataStructureOfDelaun)& theMesh,
83                                   const IMeshData::VectorOfInteger& theIndexes)
84   {
85     double aPtSum = 0;
86     const int aNbElemNodes = theIndexes.Size();
87     for (int aNodeIter = theIndexes.Lower(); aNodeIter <= theIndexes.Upper(); ++aNodeIter)
88     {
89       int aNodeNext = theIndexes.Lower() + ((aNodeIter + 1) % aNbElemNodes);
90       const BRepMesh_Vertex& aVert1 = theMesh->GetNode (theIndexes.Value (aNodeIter));
91       const BRepMesh_Vertex& aVert2 = theMesh->GetNode (theIndexes.Value (aNodeNext));
92       aPtSum += (aVert2.Coord().X() - aVert1.Coord().X())
93               * (aVert2.Coord().Y() + aVert1.Coord().Y());
94     }
95     return aPtSum < 0.0;
96   }
97 }
98
99 // ================================================================
100 // Function : Read
101 // Purpose  :
102 // ================================================================
103 RWObj_Reader::RWObj_Reader()
104 : myMemLimitBytes (Standard_Size(-1)),
105   myMemEstim (0),
106   myNbLines (0),
107   myNbProbeNodes (0),
108   myNbProbeElems (0),
109   myNbElemsBig (0),
110   myToAbort (false)
111 {
112   //
113 }
114
115 // ================================================================
116 // Function : read
117 // Purpose  :
118 // ================================================================
119 Standard_Boolean RWObj_Reader::read (const TCollection_AsciiString& theFile,
120                                      const Handle(Message_ProgressIndicator)& theProgress,
121                                      const Standard_Boolean theToProbe)
122 {
123   myMemEstim = 0;
124   myNbLines = 0;
125   myNbProbeNodes = 0;
126   myNbProbeElems = 0;
127   myNbElemsBig = 0;
128   myToAbort = false;
129   myObjVerts.Reset();
130   myObjVertsUV.Clear();
131   myObjNorms.Clear();
132   myPackedIndices.Clear();
133   myMaterials.Clear();
134   myFileComments.Clear();
135   myExternalFiles.Clear();
136   myActiveSubMesh = RWObj_SubMesh();
137
138   // determine file location to load associated files
139   TCollection_AsciiString aFileName;
140   OSD_Path::FolderAndFileFromPath (theFile, myFolder, aFileName);
141   myCurrElem.resize (1024, -1);
142
143   Standard_CLocaleSentry aLocaleSentry;
144   RWObj_ReaderFile aFile (theFile);
145   if (aFile.File == NULL)
146   {
147     Message::SendFail (TCollection_AsciiString ("Error: file '") + theFile + "' is not found");
148     return Standard_False;
149   }
150
151   // determine length of file
152   const int64_t aFileLen = aFile.FileLen;
153   if (aFileLen <= 0L)
154   {
155     Message::SendFail (TCollection_AsciiString ("Error: file '") + theFile + "' is empty");
156     return Standard_False;
157   }
158
159   Standard_ReadLineBuffer aBuffer (THE_BUFFER_SIZE);
160   aBuffer.SetMultilineMode (true);
161
162   const Standard_Integer aNbMiBTotal  = Standard_Integer(aFileLen / (1024 * 1024));
163   Standard_Integer       aNbMiBPassed = 0;
164   Message_ProgressSentry aPSentry (theProgress, "Reading text OBJ file", 0, aNbMiBTotal, 1);
165   OSD_Timer aTimer;
166   aTimer.Start();
167
168   bool isStart = true;
169   int64_t aPosition = 0;
170   size_t aLineLen = 0;
171   int64_t aReadBytes = 0;
172   const char* aLine = NULL;
173   for (;;)
174   {
175     aLine = aBuffer.ReadLine (aFile.File, aLineLen, aReadBytes);
176     if (aLine == NULL)
177     {
178       break;
179     }
180     ++myNbLines;
181     aPosition += aReadBytes;
182     if (aTimer.ElapsedTime() > 1.0)
183     {
184       if (!aPSentry.More())
185       {
186         return false;
187       }
188
189       const Standard_Integer aNbMiBRead = Standard_Integer(aPosition / (1024 * 1024));
190       for (; aNbMiBPassed < aNbMiBRead; ++aNbMiBPassed) { aPSentry.Next(); }
191       aTimer.Reset();
192       aTimer.Start();
193     }
194
195     if (*aLine == '#')
196     {
197       if (isStart)
198       {
199         TCollection_AsciiString aComment (aLine + 1);
200         aComment.LeftAdjust();
201         aComment.RightAdjust();
202         if (!aComment.IsEmpty())
203         {
204           if (!myFileComments.IsEmpty())
205           {
206             myFileComments += "\n";
207           }
208           myFileComments += aComment;
209         }
210       }
211       continue;
212     }
213     else if (*aLine == '\n'
214           || *aLine == '\0')
215     {
216
217       continue;
218     }
219     isStart = false;
220
221     if (theToProbe)
222     {
223       if (::strncmp (aLine, "mtllib", 6) == 0)
224       {
225         readMaterialLib (IsSpace (aLine[6]) ? aLine + 7 : "");
226       }
227       else if (aLine[0] == 'v' && RWObj_Tools::isSpaceChar (aLine[1]))
228       {
229         ++myNbProbeNodes;
230       }
231       else if (aLine[0] == 'f' && RWObj_Tools::isSpaceChar (aLine[1]))
232       {
233         ++myNbProbeElems;
234       }
235       continue;
236     }
237
238     if (aLine[0] == 'v' && RWObj_Tools::isSpaceChar (aLine[1]))
239     {
240       ++myNbProbeNodes;
241       pushVertex (aLine + 2);
242     }
243     else if (aLine[0] == 'v'
244           && aLine[1] == 'n'
245           && RWObj_Tools::isSpaceChar (aLine[2]))
246     {
247       pushNormal (aLine + 3);
248     }
249     else if (aLine[0] == 'v'
250           && aLine[1] == 't'
251           && RWObj_Tools::isSpaceChar (aLine[2]))
252     {
253       pushTexel (aLine + 3);
254     }
255     else if (aLine[0] == 'f' && RWObj_Tools::isSpaceChar (aLine[1]))
256     {
257       ++myNbProbeElems;
258       pushIndices (aLine + 2);
259     }
260     else if (aLine[0] == 'g' && IsSpace (aLine[1]))
261     {
262       pushGroup (aLine + 2);
263     }
264     else if (aLine[0] == 's' && IsSpace (aLine[1]))
265     {
266       pushSmoothGroup (aLine + 2);
267     }
268     else if (aLine[0] == 'o' && IsSpace (aLine[1]))
269     {
270       pushObject (aLine + 2);
271     }
272     else if (::strncmp (aLine, "mtllib", 6) == 0)
273     {
274       readMaterialLib (IsSpace (aLine[6]) ? aLine + 7 : "");
275     }
276     else if (::strncmp (aLine, "usemtl", 6) == 0)
277     {
278       pushMaterial (IsSpace (aLine[6]) ? aLine + 7 : "");
279     }
280
281     if (!checkMemory())
282     {
283       addMesh (myActiveSubMesh, RWObj_SubMeshReason_NewObject);
284       return false;
285     }
286   }
287
288   // collect external references
289   for (NCollection_DataMap<TCollection_AsciiString, RWObj_Material>::Iterator aMatIter (myMaterials); aMatIter.More(); aMatIter.Next())
290   {
291     const RWObj_Material& aMat = aMatIter.Value();
292     if (!aMat.DiffuseTexture.IsEmpty())
293     {
294       myExternalFiles.Add (aMat.DiffuseTexture);
295     }
296     if (!aMat.SpecularTexture.IsEmpty())
297     {
298       myExternalFiles.Add (aMat.SpecularTexture);
299     }
300     if (!aMat.BumpTexture.IsEmpty())
301     {
302       myExternalFiles.Add (aMat.BumpTexture);
303     }
304   }
305
306   // flush the last group
307   if (!theToProbe)
308   {
309     addMesh (myActiveSubMesh, RWObj_SubMeshReason_NewObject);
310   }
311   if (myNbElemsBig != 0)
312   {
313     Message::SendWarning (TCollection_AsciiString("Warning: OBJ reader, ") + myNbElemsBig + " polygon(s) have been split into triangles");
314   }
315
316   for (; aNbMiBPassed < aNbMiBTotal; ++aNbMiBPassed) { aPSentry.Next(); }
317   return true;
318 }
319
320 // =======================================================================
321 // function : pushIndices
322 // purpose  :
323 // =======================================================================
324 void RWObj_Reader::pushIndices (const char* thePos)
325 {
326   char* aNext = NULL;
327
328   Standard_Integer aNbElemNodes = 0;
329   for (Standard_Integer aNode = 0;; ++aNode)
330   {
331     Graphic3d_Vec3i a3Indices (-1, -1, -1);
332     a3Indices[0] = strtol (thePos, &aNext, 10) - 1;
333     if (aNext == thePos)
334     {
335       break;
336     }
337
338     // parse UV index
339     thePos = aNext;
340     if (*thePos == '/')
341     {
342       ++thePos;
343       a3Indices[1] = strtol (thePos, &aNext, 10) - 1;
344       thePos = aNext;
345
346       // parse Normal index
347       if (*thePos == '/')
348       {
349         ++thePos;
350         a3Indices[2] = strtol (thePos, &aNext, 10) - 1;
351         thePos = aNext;
352       }
353     }
354
355     // handle negative indices
356     if (a3Indices[0] < -1)
357     {
358       a3Indices[0] += myObjVerts.Upper() + 2;
359     }
360     if (a3Indices[1] < -1)
361     {
362       a3Indices[1] += myObjVertsUV.Upper() + 2;
363     }
364     if (a3Indices[2] < -1)
365     {
366       a3Indices[2] += myObjNorms.Upper() + 2;
367     }
368
369     Standard_Integer anIndex = -1;
370     if (!myPackedIndices.Find (a3Indices, anIndex))
371     {
372       if (a3Indices[0] >= 0)
373       {
374         myMemEstim += sizeof(Graphic3d_Vec3);
375       }
376       if (a3Indices[1] >= 0)
377       {
378         myMemEstim += sizeof(Graphic3d_Vec2);
379       }
380       if (a3Indices[2] >= 0)
381       {
382         myMemEstim += sizeof(Graphic3d_Vec3);
383       }
384       myMemEstim += sizeof(Graphic3d_Vec4i) + sizeof(Standard_Integer); // naive map
385       if (a3Indices[0] < myObjVerts.Lower() || a3Indices[0] > myObjVerts.Upper())
386       {
387         myToAbort = true;
388         Message::SendFail (TCollection_AsciiString("Error: invalid OBJ syntax at line ") + myNbLines + ": vertex index is out of range");
389         return;
390       }
391
392       anIndex = addNode (myObjVerts.Value (a3Indices[0]));
393       myPackedIndices.Bind (a3Indices, anIndex);
394       if (a3Indices[1] >= 0)
395       {
396         if (myObjVertsUV.IsEmpty())
397         {
398           Message::SendWarning (TCollection_AsciiString("Warning: invalid OBJ syntax at line ") + myNbLines
399                               + ": UV index is specified but no UV nodes are defined");
400         }
401         else if (a3Indices[1] < myObjVertsUV.Lower() || a3Indices[1] > myObjVertsUV.Upper())
402         {
403           Message::SendWarning (TCollection_AsciiString("Warning: invalid OBJ syntax at line ") + myNbLines
404                               + ": UV index is out of range");
405           setNodeUV (anIndex,Graphic3d_Vec2 (0.0f, 0.0f));
406         }
407         else
408         {
409           setNodeUV (anIndex, myObjVertsUV.Value (a3Indices[1]));
410         }
411       }
412       if (a3Indices[2] >= 0)
413       {
414         if (myObjNorms.IsEmpty())
415         {
416           Message::SendWarning (TCollection_AsciiString("Warning: invalid OBJ syntax at line ") + myNbLines
417                               + ": Normal index is specified but no Normals nodes are defined");
418         }
419         else if (a3Indices[2] < myObjNorms.Lower() || a3Indices[2] > myObjNorms.Upper())
420         {
421           Message::SendWarning (TCollection_AsciiString("Warning: invalid OBJ syntax at line ") + myNbLines
422                               + ": Normal index is out of range");
423           setNodeNormal (anIndex, Graphic3d_Vec3 (0.0f, 0.0f, 1.0f));
424         }
425         else
426         {
427           setNodeNormal (anIndex, myObjNorms.Value (a3Indices[2]));
428         }
429       }
430     }
431
432     if (myCurrElem.size() < size_t(aNode))
433     {
434       myCurrElem.resize (aNode * 2, -1);
435     }
436     myCurrElem[aNode] = anIndex;
437     aNbElemNodes = aNode + 1;
438
439     if (*thePos == '\n'
440      || *thePos == '\0')
441     {
442       break;
443     }
444
445     if (*thePos != ' ')
446     {
447       ++thePos;
448     }
449   }
450
451   if (myCurrElem[0] < 0
452    || myCurrElem[1] < 0
453    || myCurrElem[2] < 0
454    || aNbElemNodes  < 3)
455   {
456     return;
457   }
458
459   if (aNbElemNodes == 3)
460   {
461     myMemEstim += sizeof(Graphic3d_Vec4i);
462     addElement (myCurrElem[0], myCurrElem[1], myCurrElem[2], -1);
463   }
464   else if (aNbElemNodes == 4)
465   {
466     myMemEstim += sizeof(Graphic3d_Vec4i);
467     addElement (myCurrElem[0], myCurrElem[1], myCurrElem[2], myCurrElem[3]);
468   }
469   else
470   {
471     const NCollection_Array1<Standard_Integer> aCurrElemArray1 (myCurrElem[0], 1, aNbElemNodes);
472     const Standard_Integer aNbAdded = triangulatePolygon (aCurrElemArray1);
473     if (aNbAdded < 1)
474     {
475       return;
476     }
477     ++myNbElemsBig;
478     myMemEstim += sizeof(Graphic3d_Vec4i) * aNbAdded;
479   }
480 }
481
482 //================================================================
483 // Function : triangulatePolygonFan
484 // Purpose  :
485 //================================================================
486 Standard_Integer RWObj_Reader::triangulatePolygonFan (const NCollection_Array1<Standard_Integer>& theIndices)
487 {
488   const Standard_Integer aNbElemNodes = theIndices.Size();
489   for (Standard_Integer aNodeIter = 0; aNodeIter < aNbElemNodes - 2; ++aNodeIter)
490   {
491     Graphic3d_Vec4i aTriNodes (-1, -1, -1, -1);
492     for (Standard_Integer aNodeInSubTriIter = 0; aNodeInSubTriIter < 3; ++aNodeInSubTriIter)
493     {
494       const Standard_Integer aCurrNodeIndex = (aNodeInSubTriIter == 0) ? 0 : (aNodeIter + aNodeInSubTriIter);
495       aTriNodes[aNodeInSubTriIter] = theIndices.Value (theIndices.Lower() + aCurrNodeIndex);
496     }
497     addElement (aTriNodes[0], aTriNodes[1], aTriNodes[2], -1);
498   }
499   return aNbElemNodes - 2;
500 }
501
502 //================================================================
503 // Function : polygonCenter
504 // Purpose  :
505 //================================================================
506 gp_XYZ RWObj_Reader::polygonCenter (const NCollection_Array1<Standard_Integer>& theIndices)
507 {
508   if (theIndices.Size() < 3)
509   {
510     return gp_XYZ (0.0, 0.0, 0.0);
511   }
512   else if (theIndices.Size() == 4)
513   {
514     gp_XYZ aCenter = getNode (theIndices.Value (theIndices.Lower() + 0)).XYZ()
515                    + getNode (theIndices.Value (theIndices.Lower() + 2)).XYZ();
516     aCenter /= 2.0;
517     return aCenter;
518   }
519
520   gp_XYZ aCenter (0, 0, 0);
521   for (NCollection_Array1<Standard_Integer>::Iterator aPntIter (theIndices); aPntIter.More(); aPntIter.Next())
522   {
523     aCenter += getNode (aPntIter.Value()).XYZ();
524   }
525
526   aCenter /= (Standard_Real )theIndices.Size();
527   return aCenter;
528 }
529
530 //================================================================
531 // Function : polygonNormal
532 // Purpose  :
533 //================================================================
534 gp_XYZ RWObj_Reader::polygonNormal (const NCollection_Array1<Standard_Integer>& theIndices)
535 {
536   const gp_XYZ aCenter = polygonCenter (theIndices);
537   gp_XYZ aMaxDir = getNode (theIndices.First()).XYZ() - aCenter;
538   gp_XYZ aNormal = (getNode (theIndices.Last()).XYZ() - aCenter).Crossed (aMaxDir);
539   for (int aPntIter = theIndices.Lower(); aPntIter < theIndices.Upper(); ++aPntIter)
540   {
541     const gp_XYZ aTmpDir2 = getNode (theIndices.Value (aPntIter + 1)).XYZ() - aCenter;
542     if (aTmpDir2.SquareModulus() > aMaxDir.SquareModulus())
543     {
544       aMaxDir = aTmpDir2;
545     }
546
547     const gp_XYZ aTmpDir1 = getNode (theIndices.Value (aPntIter)).XYZ() - aCenter;
548     gp_XYZ aDelta = aTmpDir1.Crossed (aTmpDir2);
549     if (aNormal.Dot (aDelta) < 0.0)
550     {
551       aDelta *= -1.0;
552     }
553     aNormal += aDelta;
554   }
555
556   const Standard_Real aMod = aNormal.Modulus();
557   if (aMod > gp::Resolution())
558   {
559     aNormal /= aMod;
560   }
561   return aNormal;
562 }
563
564 //================================================================
565 // Function : triangulatePolygon
566 // Purpose  :
567 //================================================================
568 Standard_Integer RWObj_Reader::triangulatePolygon (const NCollection_Array1<Standard_Integer>& theIndices)
569 {
570   const Standard_Integer aNbElemNodes = theIndices.Size();
571   if (aNbElemNodes < 3)
572   {
573     return 0;
574   }
575
576   const gp_XYZ aPolygonNorm = polygonNormal (theIndices);
577
578   // map polygon onto plane
579   gp_XYZ aXDir;
580   {
581     const double aAbsXYZ[] = { Abs(aPolygonNorm.X()), Abs(aPolygonNorm.Y()), Abs(aPolygonNorm.Z()) };
582     Standard_Integer aMinI = (aAbsXYZ[0] < aAbsXYZ[1]) ? 0 : 1;
583     aMinI = (aAbsXYZ[aMinI] < aAbsXYZ[2]) ? aMinI : 2;
584     const Standard_Integer aI1 = (aMinI + 1) % 3 + 1;
585     const Standard_Integer aI2 = (aMinI + 2) % 3 + 1;
586     aXDir.ChangeCoord (aMinI + 1) = 0;
587     aXDir.ChangeCoord (aI1) =  aPolygonNorm.Coord (aI2);
588     aXDir.ChangeCoord (aI2) = -aPolygonNorm.Coord (aI1);
589   }
590   const gp_XYZ aYDir = aPolygonNorm ^ aXDir;
591
592   Handle(NCollection_IncAllocator) anAllocator = new NCollection_IncAllocator();
593   Handle(BRepMesh_DataStructureOfDelaun) aMeshStructure = new BRepMesh_DataStructureOfDelaun (anAllocator);
594   IMeshData::VectorOfInteger anIndexes (aNbElemNodes, anAllocator);
595   for (Standard_Integer aNodeIter = 0; aNodeIter < aNbElemNodes; ++aNodeIter)
596   {
597     const Standard_Integer aNodeIndex = theIndices.Value (theIndices.Lower() + aNodeIter);
598     const gp_XYZ aPnt3d = getNode (aNodeIndex).XYZ();
599     gp_XY aPnt2d (aXDir * aPnt3d, aYDir * aPnt3d);
600     BRepMesh_Vertex aVertex (aPnt2d, aNodeIndex, BRepMesh_Frontier);
601     anIndexes.Append (aMeshStructure->AddNode (aVertex));
602   }
603
604   const bool isClockwiseOrdered = isClockwisePolygon (aMeshStructure, anIndexes);
605   for (Standard_Integer aIdx = anIndexes.Lower(); aIdx <= anIndexes.Upper(); ++aIdx)
606   {
607     const Standard_Integer aPtIdx     = isClockwiseOrdered ? aIdx : (aIdx + 1) % anIndexes.Length();
608     const Standard_Integer aNextPtIdx = isClockwiseOrdered ? (aIdx + 1) % anIndexes.Length() : aIdx;
609     BRepMesh_Edge anEdge (anIndexes.Value (aPtIdx),
610                           anIndexes.Value (aNextPtIdx),
611                           BRepMesh_Frontier);
612     aMeshStructure->AddLink (anEdge);
613   }
614
615   try
616   {
617     BRepMesh_Delaun aTriangulation (aMeshStructure, anIndexes);
618     const IMeshData::MapOfInteger& aTriangles = aMeshStructure->ElementsOfDomain();
619     if (aTriangles.Extent() < 1)
620     {
621       return triangulatePolygonFan (theIndices);
622     }
623
624     Standard_Integer aNbTrisAdded = 0;
625     for (IMeshData::MapOfInteger::Iterator aTriIter (aTriangles); aTriIter.More(); aTriIter.Next())
626     {
627       const Standard_Integer aTriangleId = aTriIter.Key();
628       const BRepMesh_Triangle& aTriangle = aMeshStructure->GetElement (aTriangleId);
629       if (aTriangle.Movability() == BRepMesh_Deleted)
630       {
631         continue;
632       }
633
634       int aTri2d[3];
635       aMeshStructure->ElementNodes (aTriangle, aTri2d);
636       if (!isClockwiseOrdered)
637       {
638         std::swap (aTri2d[1], aTri2d[2]);
639       }
640       const BRepMesh_Vertex& aVertex1 = aMeshStructure->GetNode (aTri2d[0]);
641       const BRepMesh_Vertex& aVertex2 = aMeshStructure->GetNode (aTri2d[1]);
642       const BRepMesh_Vertex& aVertex3 = aMeshStructure->GetNode (aTri2d[2]);
643       addElement (aVertex1.Location3d(), aVertex2.Location3d(), aVertex3.Location3d(), -1);
644       ++aNbTrisAdded;
645     }
646     return aNbTrisAdded;
647   }
648   catch (Standard_Failure const& theFailure)
649   {
650     Message::SendWarning (TCollection_AsciiString ("Error: exception raised during polygon split\n[") + theFailure.GetMessageString() + "]");
651   }
652   return triangulatePolygonFan (theIndices);
653 }
654
655 // =======================================================================
656 // function : pushObject
657 // purpose  :
658 // =======================================================================
659 void RWObj_Reader::pushObject (const char* theObjectName)
660 {
661   TCollection_AsciiString aNewObject;
662   if (!RWObj_Tools::ReadName (theObjectName, aNewObject))
663   {
664     // empty group name is OK
665   }
666   if (addMesh (myActiveSubMesh, RWObj_SubMeshReason_NewObject))
667   {
668     myPackedIndices.Clear(); // vertices might be duplicated after this point...
669   }
670   myActiveSubMesh.Object = aNewObject;
671 }
672
673 // =======================================================================
674 // function : pushGroup
675 // purpose  :
676 // =======================================================================
677 void RWObj_Reader::pushGroup (const char* theGroupName)
678 {
679   TCollection_AsciiString aNewGroup;
680   if (!RWObj_Tools::ReadName (theGroupName, aNewGroup))
681   {
682     // empty group name is OK
683   }
684   if (addMesh (myActiveSubMesh, RWObj_SubMeshReason_NewGroup))
685   {
686     myPackedIndices.Clear(); // vertices might be duplicated after this point...
687   }
688   myActiveSubMesh.Group = aNewGroup;
689 }
690
691 // =======================================================================
692 // function : pushSmoothGroup
693 // purpose  :
694 // =======================================================================
695 void RWObj_Reader::pushSmoothGroup (const char* theSmoothGroupIndex)
696 {
697   TCollection_AsciiString aNewSmoothGroup;
698   RWObj_Tools::ReadName (theSmoothGroupIndex, aNewSmoothGroup);
699   if (aNewSmoothGroup == "off"
700    || aNewSmoothGroup == "0")
701   {
702     aNewSmoothGroup.Clear();
703   }
704   if (myActiveSubMesh.SmoothGroup.IsEqual (aNewSmoothGroup))
705   {
706     // Ignore duplicated statements to workaround some weird OBJ files.
707     // Note that smooth groups are handled in different manner than groups and objects,
708     // which always flushed even with equal names.
709     return;
710   }
711
712   if (addMesh (myActiveSubMesh, RWObj_SubMeshReason_NewSmoothGroup))
713   {
714     myPackedIndices.Clear(); // vertices might be duplicated after this point...
715   }
716   myActiveSubMesh.SmoothGroup = aNewSmoothGroup;
717 }
718
719 // =======================================================================
720 // function : pushMaterial
721 // purpose  :
722 // =======================================================================
723 void RWObj_Reader::pushMaterial (const char* theMaterialName)
724 {
725   TCollection_AsciiString aNewMat;
726   if (!RWObj_Tools::ReadName (theMaterialName, aNewMat))
727   {
728     // empty material name is allowed by specs
729   }
730   else if (!myMaterials.IsBound (aNewMat))
731   {
732     Message::SendWarning (TCollection_AsciiString("Warning: use of undefined OBJ material at line ") + myNbLines);
733     return;
734   }
735   if (myActiveSubMesh.Material.IsEqual (aNewMat))
736   {
737     return; // ignore
738   }
739
740   // implicitly create a new group to split materials
741   if (addMesh (myActiveSubMesh, RWObj_SubMeshReason_NewMaterial))
742   {
743     myPackedIndices.Clear(); // vertices might be duplicated after this point...
744   }
745   myActiveSubMesh.Material = aNewMat;
746 }
747
748 // =======================================================================
749 // function : readMaterialLib
750 // purpose  :
751 // =======================================================================
752 void RWObj_Reader::readMaterialLib (const char* theFileName)
753 {
754   TCollection_AsciiString aMatPath;
755   if (!RWObj_Tools::ReadName (theFileName, aMatPath))
756   {
757     Message::SendWarning (TCollection_AsciiString("Warning: invalid OBJ syntax at line ") + myNbLines);
758     return;
759   }
760
761   RWObj_MtlReader aMatReader (myMaterials);
762   if (aMatReader.Read (myFolder, aMatPath))
763   {
764     myExternalFiles.Add (myFolder + aMatPath);
765   }
766 }
767
768 // =======================================================================
769 // function : checkMemory
770 // purpose  :
771 // =======================================================================
772 bool RWObj_Reader::checkMemory()
773 {
774   if (myMemEstim < myMemLimitBytes
775    || myToAbort)
776   {
777     return true;
778   }
779
780   Message::SendFail (TCollection_AsciiString("Error: OBJ file content does not fit into ")
781                    + Standard_Integer(myMemLimitBytes / (1024 * 1024)) + " MiB limit."
782                    + "\nMesh data will be truncated.");
783   myToAbort = true;
784   return false;
785 }