0029597: Data Exchange - unable to read VRML2 file
[occt.git] / src / VrmlData / VrmlData_Geometry.cxx
1 // Created on: 2006-05-25
2 // Created by: Alexander GRIGORIEV
3 // Copyright (c) 2006-2014 OPEN CASCADE SAS
4 //
5 // This file is part of Open CASCADE Technology software library.
6 //
7 // This library is free software; you can redistribute it and/or modify it under
8 // the terms of the GNU Lesser General Public License version 2.1 as published
9 // by the Free Software Foundation, with special exception defined in the file
10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 // distribution for complete text of the license and disclaimer of any warranty.
12 //
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement.
15
16 #include <VrmlData_Scene.hxx>
17 #include <VrmlData_Coordinate.hxx>
18 #include <VrmlData_Color.hxx>
19 #include <VrmlData_Normal.hxx>
20 #include <VrmlData_TextureCoordinate.hxx>
21 #include <VrmlData_InBuffer.hxx>
22 #include <VrmlData_Box.hxx>
23 #include <VrmlData_Cone.hxx>
24 #include <VrmlData_Cylinder.hxx>
25 #include <VrmlData_Sphere.hxx>
26 #include <VrmlData_UnknownNode.hxx>
27 #include <BRepPrimAPI_MakeBox.hxx>
28 #include <BRepPrim_Cone.hxx>
29 #include <BRepPrim_Cylinder.hxx>
30 #include <BRepPrim_Sphere.hxx>
31 #include <BRepPrim_Builder.hxx>
32 #include <NCollection_Vector.hxx>
33 #include <Standard_ErrorHandler.hxx>
34 #include <VrmlData_ArrayVec3d.hxx>
35
36 IMPLEMENT_STANDARD_RTTIEXT(VrmlData_Geometry,VrmlData_Node)
37
38 #ifdef _MSC_VER
39 #define _CRT_SECURE_NO_DEPRECATE
40 #pragma warning (disable:4996)
41 #endif
42
43 //=======================================================================
44 //function : Value
45 //purpose  : 
46 //=======================================================================
47
48 const gp_XYZ& VrmlData_ArrayVec3d::Value (const Standard_Size i) const
49 {
50   static gp_XYZ anOrigin (0., 0., 0.);
51   return i < myLength ? myArray[i] : anOrigin;
52 }
53
54 //=======================================================================
55 //function : AllocateValues
56 //purpose  : 
57 //=======================================================================
58
59 Standard_Boolean VrmlData_ArrayVec3d::AllocateValues
60                                 (const Standard_Size theLength)
61 {
62   myArray = reinterpret_cast <const gp_XYZ *>
63     (Scene().Allocator()->Allocate (theLength*sizeof(gp_XYZ)));
64   myLength = theLength;
65   return (myArray != 0L);
66 }
67
68 //=======================================================================
69 //function : VrmlData_Box::TShape
70 //purpose  : 
71 //=======================================================================
72
73 const Handle(TopoDS_TShape)& VrmlData_Box::TShape ()
74 {
75   if (myIsModified) {
76     try {
77       const TopoDS_Shell aShell =
78         BRepPrimAPI_MakeBox (gp_Pnt (-0.5 * mySize),
79                              mySize.X(), mySize.Y(), mySize.Z());
80       SetTShape (aShell.TShape());
81       myIsModified = Standard_False;
82     } catch (Standard_Failure) {
83       myTShape.Nullify();
84     }
85   }
86   return myTShape;
87 }
88
89 //=======================================================================
90 //function : VrmlData_Box::Clone
91 //purpose  : 
92 //=======================================================================
93
94 Handle(VrmlData_Node) VrmlData_Box::Clone
95                                 (const Handle(VrmlData_Node)& theOther) const
96 {
97   Handle(VrmlData_Box) aResult =
98     Handle(VrmlData_Box)::DownCast (VrmlData_Node::Clone(theOther));
99   if (aResult.IsNull())
100     aResult = new VrmlData_Box (theOther.IsNull() ? Scene() : theOther->Scene(),
101                                 Name());
102   aResult->SetSize(mySize);
103   return aResult;
104 }
105
106 //=======================================================================
107 //function : VrmlData_Box::Read
108 //purpose  : 
109 //=======================================================================
110
111 VrmlData_ErrorStatus VrmlData_Box::Read (VrmlData_InBuffer& theBuffer)
112 {
113   VrmlData_ErrorStatus aStatus;
114   if (OK(aStatus, VrmlData_Scene::ReadLine(theBuffer))) {
115     if (VRMLDATA_LCOMPARE (theBuffer.LinePtr, "size"))
116       aStatus = Scene().ReadXYZ (theBuffer, mySize,
117                                  Standard_True, Standard_True);
118     if (OK(aStatus))
119       aStatus = readBrace (theBuffer);
120   }
121   return aStatus;
122 }
123
124 //=======================================================================
125 //function : VrmlData_Box::Write
126 //purpose  : 
127 //=======================================================================
128
129 VrmlData_ErrorStatus VrmlData_Box::Write (const char * thePrefix) const
130 {
131   static char header[] = "Box {";
132   VrmlData_ErrorStatus aStatus;
133   if (OK (aStatus, Scene().WriteLine (thePrefix, header, GlobalIndent())))
134   {
135     char buf[128];
136     Sprintf (buf, "size %.12g %.12g %.12g", mySize.X(), mySize.Y(), mySize.Z());
137     Scene().WriteLine (buf);
138     aStatus = WriteClosing();
139   }
140   return aStatus;
141 }
142
143 //=======================================================================
144 //function : VrmlData_Cone::TShape
145 //purpose  : 
146 //=======================================================================
147
148 const Handle(TopoDS_TShape)& VrmlData_Cone::TShape ()
149 {
150   if (myIsModified && (myHasBottom || myHasSide)) {
151     try {
152       gp_Ax2 aLocalAxis (gp_Pnt (0., -0.5 * myHeight, 0.),
153                          gp_Dir (0., 1., 0.));
154       BRepPrim_Cone aBuilder (aLocalAxis, myBottomRadius, 0., myHeight);
155       if (!myHasBottom)
156         myTShape = aBuilder.LateralFace().TShape();
157       else if (!myHasSide) 
158         myTShape = aBuilder.BottomFace().TShape();
159       else
160         myTShape = aBuilder.Shell().TShape();
161       myIsModified = Standard_False;
162     } catch (Standard_Failure) {
163       myTShape.Nullify();
164     }
165   }
166   return myTShape;
167 }
168
169 //=======================================================================
170 //function : VrmlData_Cone::Clone
171 //purpose  : 
172 //=======================================================================
173
174 Handle(VrmlData_Node) VrmlData_Cone::Clone
175                                 (const Handle(VrmlData_Node)& theOther) const
176 {
177   Handle(VrmlData_Cone) aResult =
178     Handle(VrmlData_Cone)::DownCast (VrmlData_Node::Clone(theOther));
179   if (aResult.IsNull())
180     aResult = new VrmlData_Cone (theOther.IsNull() ? Scene(): theOther->Scene(),
181                                 Name());
182
183   aResult->SetBottomRadius (myBottomRadius);
184   aResult->SetHeight (myHeight);
185   aResult->SetFaces (myHasBottom, myHasSide);
186   return aResult;
187 }
188
189 //=======================================================================
190 //function : VrmlData_Cone::Read
191 //purpose  : 
192 //=======================================================================
193
194 VrmlData_ErrorStatus VrmlData_Cone::Read (VrmlData_InBuffer& theBuffer)
195 {
196   VrmlData_ErrorStatus aStatus;
197   Standard_Boolean hasSide(Standard_True), hasBottom(Standard_True);
198
199   while (OK(aStatus, VrmlData_Scene::ReadLine(theBuffer)))
200   {
201     if (VRMLDATA_LCOMPARE (theBuffer.LinePtr, "bottomRadius"))
202       aStatus = Scene().ReadReal (theBuffer, myBottomRadius,
203                                   Standard_True, Standard_True);
204     else if (VRMLDATA_LCOMPARE (theBuffer.LinePtr, "height"))
205       aStatus = Scene().ReadReal (theBuffer, myHeight,
206                                   Standard_True, Standard_True);
207     else if (VRMLDATA_LCOMPARE (theBuffer.LinePtr, "side")) {
208       if (OK(aStatus, ReadBoolean (theBuffer, hasSide)))
209         myHasSide = hasSide;
210     } else if (VRMLDATA_LCOMPARE (theBuffer.LinePtr, "bottom")) {
211       if (OK(aStatus, ReadBoolean (theBuffer, hasBottom)))
212         myHasBottom = hasBottom;
213     } else
214       break;
215
216     if (!OK(aStatus))
217       break;
218   }
219   // Read the terminating (closing) brace
220   if (OK(aStatus))
221     aStatus = readBrace (theBuffer);
222   return aStatus;
223 }
224
225 //=======================================================================
226 //function : VrmlData_Cone::Write
227 //purpose  : 
228 //=======================================================================
229
230 VrmlData_ErrorStatus VrmlData_Cone::Write (const char * thePrefix) const
231 {
232   static char header[] = "Cone {";
233   VrmlData_ErrorStatus aStatus;
234   if (OK (aStatus, Scene().WriteLine (thePrefix, header, GlobalIndent())))
235   {
236     char buf[128];
237     if ((myBottomRadius - 1.)*(myBottomRadius - 1.) > Precision::Confusion()) {
238       Sprintf (buf, "bottomRadius %.12g", myBottomRadius);
239       aStatus = Scene().WriteLine (buf);
240     }
241     if (OK(aStatus) &&
242         (myHeight - 2.)*(myHeight - 2.) > Precision::Confusion()) {
243       Sprintf (buf, "height       %.12g", myHeight);
244       aStatus = Scene().WriteLine (buf);
245     }
246     if (OK(aStatus) && myHasBottom == Standard_False)
247       aStatus = Scene().WriteLine ("bottom   FALSE");
248     if (OK(aStatus) && myHasSide == Standard_False)
249       aStatus = Scene().WriteLine ("side     FALSE");
250
251     aStatus = WriteClosing();
252   }
253   return aStatus;
254 }
255
256 //=======================================================================
257 //function : VrmlData_Cone::IsDefault
258 //purpose  : 
259 //=======================================================================
260
261 // Standard_Boolean VrmlData_Cone::IsDefault () const
262 // {
263 //   return
264 //     (myHasBottom && myHasSide &&
265 //      ((myBottomRadius - 1.)*(myBottomRadius-1.) < Precision::Confusion()) &&
266 //      ((myHeight - 2.)*(myHeight - 2.) < Precision::Confusion()));
267 // }
268
269 //=======================================================================
270 //function : VrmlData_Cylinder::TShape
271 //purpose  : 
272 //=======================================================================
273
274 const Handle(TopoDS_TShape)& VrmlData_Cylinder::TShape ()
275 {
276   if (myIsModified && (myHasBottom || myHasSide || myHasTop)) {
277     try {
278       gp_Ax2 aLocalAxis (gp_Pnt (0., -0.5 * myHeight, 0.),
279                          gp_Dir (0., 1., 0.));
280       BRepPrim_Cylinder aBuilder (aLocalAxis, myRadius, myHeight);
281       BRepPrim_Builder aShapeBuilder;
282       TopoDS_Shell aShell;
283       aShapeBuilder.MakeShell(aShell);
284       if (myHasSide)
285         aShapeBuilder.AddShellFace (aShell, aBuilder.LateralFace());
286       if (myHasTop)
287         aShapeBuilder.AddShellFace (aShell, aBuilder.TopFace());
288       if (myHasBottom)
289         aShapeBuilder.AddShellFace (aShell, aBuilder.BottomFace());
290       myTShape = aShell.TShape();
291       myIsModified = Standard_False;
292     } catch (Standard_Failure) {
293       myTShape.Nullify();
294     }
295   }
296   return myTShape;
297 }
298
299 //=======================================================================
300 //function : VrmlData_Cylinder::Clone
301 //purpose  : 
302 //=======================================================================
303
304 Handle(VrmlData_Node) VrmlData_Cylinder::Clone
305                                 (const Handle(VrmlData_Node)& theOther) const
306 {
307   Handle(VrmlData_Cylinder) aResult =
308     Handle(VrmlData_Cylinder)::DownCast (VrmlData_Node::Clone(theOther));
309   if (aResult.IsNull())
310     aResult = new VrmlData_Cylinder(theOther.IsNull()?Scene():theOther->Scene(),
311                                     Name());
312   aResult->SetRadius (myRadius);
313   aResult->SetHeight (myHeight);
314   aResult->SetFaces  (myHasBottom, myHasSide, myHasTop);
315   return aResult;
316 }
317
318 //=======================================================================
319 //function : VrmlData_Cylinder::Read
320 //purpose  : 
321 //=======================================================================
322
323 VrmlData_ErrorStatus VrmlData_Cylinder::Read (VrmlData_InBuffer& theBuffer)
324 {
325   VrmlData_ErrorStatus aStatus;
326   Standard_Boolean hasSide(Standard_True), hasBottom(Standard_True);
327   Standard_Boolean hasTop (Standard_True);
328
329   while (OK(aStatus, VrmlData_Scene::ReadLine(theBuffer)))
330   {
331     if (VRMLDATA_LCOMPARE (theBuffer.LinePtr, "radius"))
332       aStatus = Scene().ReadReal (theBuffer, myRadius,
333                                   Standard_True, Standard_True);
334     else if (VRMLDATA_LCOMPARE (theBuffer.LinePtr, "height"))
335       aStatus = Scene().ReadReal (theBuffer, myHeight,
336                                   Standard_True, Standard_True);
337     else if (VRMLDATA_LCOMPARE (theBuffer.LinePtr, "top")) {
338       if (OK(aStatus, ReadBoolean (theBuffer, hasTop)))
339         myHasTop = hasTop;
340     } else if (VRMLDATA_LCOMPARE (theBuffer.LinePtr, "side")) {
341       if (OK(aStatus, ReadBoolean (theBuffer, hasSide)))
342         myHasSide = hasSide;
343     } else if (VRMLDATA_LCOMPARE (theBuffer.LinePtr, "bottom")) {
344       if (OK(aStatus, ReadBoolean (theBuffer, hasBottom)))
345         myHasBottom = hasBottom;
346     } else
347       break;
348
349     if (!OK(aStatus))
350       break;
351   }
352
353   // Read the terminating (closing) brace
354   if (OK(aStatus))
355     aStatus = readBrace (theBuffer);
356   return aStatus;
357 }
358
359 //=======================================================================
360 //function : VrmlData_Cylinder::Write
361 //purpose  : 
362 //=======================================================================
363
364 VrmlData_ErrorStatus VrmlData_Cylinder::Write (const char * thePrefix) const
365 {
366   static char header[] = "Cylinder {";
367   VrmlData_ErrorStatus aStatus;
368   if (OK (aStatus, Scene().WriteLine (thePrefix, header, GlobalIndent())))
369   {
370     char buf[128];
371     if ((myRadius - 1.)*(myRadius - 1.) > Precision::Confusion()) {
372       Sprintf (buf, "radius   %.12g", myRadius);
373       aStatus = Scene().WriteLine (buf);
374     }
375     if (OK(aStatus) &&
376         (myHeight - 2.)*(myHeight - 2.) > Precision::Confusion()) {
377       Sprintf (buf, "height   %.12g", myHeight);
378       aStatus = Scene().WriteLine (buf);
379     }
380     if (OK(aStatus) && myHasBottom == Standard_False)
381       aStatus = Scene().WriteLine ("bottom   FALSE");
382     if (OK(aStatus) && myHasSide == Standard_False)
383       aStatus = Scene().WriteLine ("side     FALSE");
384     if (OK(aStatus) && myHasTop == Standard_False)
385       aStatus = Scene().WriteLine ("top      FALSE");
386
387     aStatus = WriteClosing();
388   }
389   return aStatus;
390 }
391
392 //=======================================================================
393 //function : VrmlData_Cylinder::IsDefault
394 //purpose  : 
395 //=======================================================================
396
397 // Standard_Boolean VrmlData_Cylinder::IsDefault () const
398 // {
399 //   return
400 //     (myHasBottom && myHasSide && myHasTop &&
401 //      ((myRadius - 1.)*(myRadius - 1.) < Precision::Confusion()) &&
402 //      ((myHeight - 2.)*(myHeight - 2.) < Precision::Confusion()));
403 // }
404
405 //=======================================================================
406 //function : VrmlData_Sphere::TShape
407 //purpose  : 
408 //=======================================================================
409
410 const Handle(TopoDS_TShape)& VrmlData_Sphere::TShape ()
411 {
412   if (myIsModified) {
413     try {
414       myTShape = BRepPrim_Sphere(myRadius).Shell().TShape();
415       myIsModified = Standard_False;
416     } catch (Standard_Failure) {
417       myTShape.Nullify();
418     }
419   }
420   return myTShape;
421 }
422
423 //=======================================================================
424 //function : VrmlData_Sphere::Clone
425 //purpose  : 
426 //=======================================================================
427
428 Handle(VrmlData_Node) VrmlData_Sphere::Clone
429                                 (const Handle(VrmlData_Node)& theOther) const
430 {
431   Handle(VrmlData_Sphere) aResult =
432     Handle(VrmlData_Sphere)::DownCast (VrmlData_Node::Clone(theOther));
433   if (aResult.IsNull())
434     aResult = new VrmlData_Sphere(theOther.IsNull()? Scene() :theOther->Scene(),
435                                   Name());
436   aResult->SetRadius (myRadius);
437   return aResult;
438 }
439
440 //=======================================================================
441 //function : VrmlData_Sphere::Read
442 //purpose  : 
443 //=======================================================================
444
445 VrmlData_ErrorStatus VrmlData_Sphere::Read (VrmlData_InBuffer& theBuffer)
446 {
447   VrmlData_ErrorStatus aStatus;
448   while (OK(aStatus, VrmlData_Scene::ReadLine(theBuffer)))
449     if (VRMLDATA_LCOMPARE (theBuffer.LinePtr, "radius"))
450       aStatus = Scene().ReadReal (theBuffer, myRadius,
451                                   Standard_True, Standard_True);
452     else
453       break;
454
455   // Read the terminating (closing) brace
456   if (OK(aStatus))
457     aStatus = readBrace (theBuffer);
458   return aStatus;
459 }
460
461 //=======================================================================
462 //function : VrmlData_Sphere::Write
463 //purpose  : 
464 //=======================================================================
465
466 VrmlData_ErrorStatus VrmlData_Sphere::Write (const char * thePrefix) const
467 {
468   static char header[] = "Sphere {";
469   VrmlData_ErrorStatus aStatus;
470   if (OK (aStatus, Scene().WriteLine (thePrefix, header, GlobalIndent())))
471   {
472     char buf[128];
473     Sprintf (buf, "radius   %.12g", myRadius);
474     Scene().WriteLine (buf);
475     aStatus = WriteClosing();
476   }
477   return aStatus;
478 }
479
480 //=======================================================================
481 //function : VrmlData_Sphere::IsDefault
482 //purpose  : 
483 //=======================================================================
484
485 // Standard_Boolean VrmlData_Sphere::IsDefault () const
486 // {
487 //   return ((myRadius - 1.)*(myRadius - 1.) < Precision::Confusion())
488 // }
489
490 //=======================================================================
491 //function : VrmlData_TextureCoordinate::AllocateValues
492 //purpose  : 
493 //=======================================================================
494
495 Standard_Boolean VrmlData_TextureCoordinate::AllocateValues
496                                 (const Standard_Size theLength)
497 {
498   myPoints = reinterpret_cast <const gp_XY *>
499     (Scene().Allocator()->Allocate (theLength*sizeof(gp_XY)));
500   myLength = theLength;
501   return (myPoints != 0L);
502 }
503
504 //=======================================================================
505 //function : VrmlData_TextureCoordinate::Clone
506 //purpose  : 
507 //=======================================================================
508
509 Handle(VrmlData_Node) VrmlData_TextureCoordinate::Clone
510                                 (const Handle(VrmlData_Node)& theOther) const
511 {
512   Handle(VrmlData_TextureCoordinate) aResult =
513     Handle(VrmlData_TextureCoordinate)::DownCast
514     (VrmlData_Node::Clone(theOther));
515   if (aResult.IsNull())
516     aResult = new VrmlData_TextureCoordinate
517       (theOther.IsNull() ? Scene() : theOther->Scene(), Name());
518   if (&aResult->Scene() == &Scene())
519     aResult->SetPoints (myLength, myPoints);
520   else {
521     aResult->AllocateValues (myLength);
522     for (Standard_Size i = 0; i < myLength; i++)
523       const_cast <gp_XY&> (aResult->myPoints[i]) = myPoints[i];
524   }
525   return aResult;
526 }
527
528 //=======================================================================
529 //function : VrmlData_TextureCoordinate::Read
530 //purpose  : 
531 //=======================================================================
532
533 VrmlData_ErrorStatus VrmlData_TextureCoordinate::Read
534                                         (VrmlData_InBuffer& theBuffer)
535 {
536   VrmlData_ErrorStatus aStatus;
537   NCollection_Vector<gp_XY> vecValues;
538   if (OK(aStatus, VrmlData_Scene::ReadLine(theBuffer))) {
539     // Match the name with the current word in the stream
540     if (VRMLDATA_LCOMPARE (theBuffer.LinePtr, "point"))
541       // Read the body of the data node (comma-separated list of duplets)
542       if (OK(aStatus, VrmlData_Scene::ReadLine(theBuffer))) {
543         if (theBuffer.LinePtr[0] != '[')  // opening bracket
544           aStatus = VrmlData_VrmlFormatError;
545         else {
546           theBuffer.LinePtr++;
547           for(;;) {
548             gp_XY anXY;
549             if (!OK(aStatus, VrmlData_Scene::ReadLine(theBuffer)))
550               break;
551             // closing bracket, in case that it follows a comma
552             if (theBuffer.LinePtr[0] == ']') {
553               theBuffer.LinePtr++;
554               break;
555             }
556             if (!OK(aStatus, Scene().ReadXY(theBuffer, anXY,
557                                             Standard_False, Standard_False)))
558               break;
559             vecValues.Append(anXY);
560             if (!OK(aStatus, VrmlData_Scene::ReadLine(theBuffer)))
561               break;
562             if (theBuffer.LinePtr[0] == ',') {
563               theBuffer.LinePtr++;
564             } else if (theBuffer.LinePtr[0] == ']') { // closing bracket
565               theBuffer.LinePtr++;
566               break;
567             }
568           }
569         }
570       }
571     if (OK(aStatus) && OK(aStatus, readBrace (theBuffer))) {
572       myLength = vecValues.Length();
573       if (myLength > 0) {
574         gp_XY * aPoints = reinterpret_cast <gp_XY *>
575           (Scene().Allocator()->Allocate (myLength * sizeof(gp_XY)));
576         myPoints = aPoints;
577         for (Standard_Integer i = 0; i < Standard_Integer(myLength); i++)
578           aPoints[i] = vecValues(i);
579       }
580     }
581   }
582   return aStatus;
583 }
584
585 //=======================================================================
586 //function : VrmlData_ArrayVec3d::Clone
587 //purpose  : 
588 //=======================================================================
589
590 // Handle(VrmlData_Node) VrmlData_ArrayVec3d::Clone
591 //                                 (const Handle(VrmlData_Node)& theOther) const
592 // {
593 //   VrmlData_Node::Clone (theOther);
594 //   const Handle(VrmlData_ArrayVec3d) anArrayNode =
595 //     Handle(VrmlData_ArrayVec3d)::DownCast (theOther);
596 //   if (anArrayNode.IsNull() == Standard_False)
597 //     anArrayNode->SetValues (myLength, myArray);
598 //   return theOther;
599 // }
600
601 //=======================================================================
602 //function : VrmlData_ArrayVec3d::ReadArray
603 //purpose  : 
604 //=======================================================================
605
606 VrmlData_ErrorStatus VrmlData_ArrayVec3d::ReadArray
607                                         (VrmlData_InBuffer&     theBuffer,
608                                          const char *           theName,
609                                          const Standard_Boolean isScale)
610 {
611   VrmlData_ErrorStatus aStatus;
612   NCollection_Vector<gp_XYZ> vecValues;
613   if (OK(aStatus, VrmlData_Scene::ReadLine(theBuffer))) {
614     // Match the name with the current word in the stream
615     if (theName) {
616       const Standard_Size aNameLen = strlen(theName);
617       if (strncmp (theBuffer.LinePtr, theName, aNameLen))
618         aStatus = VrmlData_VrmlFormatError;
619       else
620         theBuffer.LinePtr += aNameLen;
621     } else {
622       // Skip the word in the input
623       while (theBuffer.LinePtr[0] != ' ' &&
624              theBuffer.LinePtr[0] != ',' &&
625              theBuffer.LinePtr[0] != '\t' &&
626              theBuffer.LinePtr[0] != '\n' &&
627              theBuffer.LinePtr[0] != '\r' &&
628              theBuffer.LinePtr[0] != '\0')
629         theBuffer.LinePtr++;
630     }
631     // Read the body of the data node (list of triplets)
632     if (OK(aStatus) && OK(aStatus, VrmlData_Scene::ReadLine(theBuffer))) {
633       if (theBuffer.LinePtr[0] != '[')  // opening bracket
634       {
635         // Handle case when brackets are ommited for single element of array
636         gp_XYZ anXYZ;
637         // Read three numbers (XYZ value)
638         if (!OK(aStatus, Scene().ReadXYZ(theBuffer, anXYZ,
639                                           isScale, Standard_False)))
640           aStatus = VrmlData_VrmlFormatError;
641         else
642           vecValues.Append(anXYZ);
643       }
644       else {
645         theBuffer.LinePtr++;
646         for(;;) {
647           gp_XYZ anXYZ;
648           if (!OK(aStatus, VrmlData_Scene::ReadLine(theBuffer)))
649             break;
650           // closing bracket, in case that it follows a comma
651           if (theBuffer.LinePtr[0] == ']') {
652             theBuffer.LinePtr++;
653             break;
654           }
655           // Read three numbers (XYZ value)
656           if (!OK(aStatus, Scene().ReadXYZ(theBuffer, anXYZ,
657                                            isScale, Standard_False)))
658             break;
659           vecValues.Append(anXYZ);
660           if (!OK(aStatus, VrmlData_Scene::ReadLine(theBuffer)))
661             break;
662           if (theBuffer.LinePtr[0] == ']') {// closing bracket
663             theBuffer.LinePtr++;
664             break;
665           }
666         }
667       }
668     }
669     if (OK(aStatus) && OK(aStatus, readBrace (theBuffer))) {
670       myLength = vecValues.Length();
671       if (myLength > 0) {
672         gp_XYZ * anArray = reinterpret_cast <gp_XYZ *>
673           (Scene().Allocator()->Allocate (myLength * sizeof(gp_XYZ)));
674         myArray = anArray;
675         for (Standard_Integer i = 0; i < Standard_Integer(myLength); i++)
676           anArray[i] = vecValues(i);
677       }
678     }
679   }
680   return aStatus;
681 }
682
683 //=======================================================================
684 //function : VrmlData_ArrayVec3d::WriteArray
685 //purpose  : 
686 //=======================================================================
687
688 VrmlData_ErrorStatus VrmlData_ArrayVec3d::WriteArray
689                                         (const char *           theName,
690                                          const Standard_Boolean isScale) const
691 {
692   VrmlData_ErrorStatus aStatus (VrmlData_StatusOK);
693   if (myLength > 0) {
694     aStatus = Scene().WriteLine (theName, "[", 2*GlobalIndent());
695     if (OK(aStatus)) {
696       for (Standard_Size i = 0; i < myLength-1; i++)
697         if (!OK (aStatus, Scene().WriteXYZ (myArray[i], isScale, ",")))
698           break;
699       if (OK(aStatus))
700         aStatus = Scene().WriteXYZ (myArray[myLength-1], isScale);
701     }
702     if (aStatus == VrmlData_StatusOK)
703       aStatus = Scene().WriteLine ("]", 0L, -2*GlobalIndent());
704   }
705   return aStatus;
706 }
707
708 //=======================================================================
709 //function : VrmlData_ArrayVec3d::IsDefault
710 //purpose  : 
711 //=======================================================================
712
713 Standard_Boolean VrmlData_ArrayVec3d::IsDefault () const
714 {
715   return myLength == 0;
716 }
717
718 //=======================================================================
719 //function : VrmlData_Coodinate::Clone
720 //purpose  : 
721 //=======================================================================
722
723 Handle(VrmlData_Node) VrmlData_Coordinate::Clone
724                                 (const Handle(VrmlData_Node)& theOther) const
725 {
726   Handle(VrmlData_Coordinate) aResult =
727     Handle(VrmlData_Coordinate)::DownCast (VrmlData_Node::Clone(theOther));
728   if (aResult.IsNull())
729     aResult = new VrmlData_Coordinate
730       (theOther.IsNull() ? Scene() : theOther->Scene(), Name());
731   if (&aResult->Scene() == &Scene())
732     aResult->SetValues (Length(), Values());
733   else {
734     aResult->AllocateValues (Length());
735     for (Standard_Size i = 0; i < Length(); i++)
736       const_cast <gp_XYZ&> (aResult->Values()[i]) = Values()[i];
737   }
738   return aResult;
739 }
740
741 //=======================================================================
742 //function : VrmlData_Coordinate::Read
743 //purpose  : 
744 //=======================================================================
745
746 VrmlData_ErrorStatus VrmlData_Coordinate::Read (VrmlData_InBuffer& theBuffer)
747 {
748   return VrmlData_ArrayVec3d::ReadArray (theBuffer, "point", Standard_True);
749 }
750
751 //=======================================================================
752 //function : VrmlData_Coordinate::Write
753 //purpose  : 
754 //=======================================================================
755
756 VrmlData_ErrorStatus VrmlData_Coordinate::Write (const char * thePrefix) const
757 {
758   static char header[] = "Coordinate {";
759   VrmlData_ErrorStatus aStatus;
760   if (OK (aStatus, Scene().WriteLine (thePrefix, header, GlobalIndent())))
761   {
762     WriteArray ("point", Standard_True);
763     aStatus = WriteClosing();
764   }
765   return aStatus;
766 }
767
768 //=======================================================================
769 //function : VrmlData_Color::Clone
770 //purpose  : 
771 //=======================================================================
772
773 Handle(VrmlData_Node) VrmlData_Color::Clone
774                                 (const Handle(VrmlData_Node)& theOther) const
775 {
776   Handle(VrmlData_Color) aResult =
777     Handle(VrmlData_Color)::DownCast (VrmlData_Node::Clone(theOther));
778   if (aResult.IsNull())
779     aResult = new VrmlData_Color(theOther.IsNull()? Scene() : theOther->Scene(),
780                                  Name());
781   if (&aResult->Scene() == &Scene())
782     aResult->SetValues (Length(), Values());
783   else {
784     aResult->AllocateValues (Length());
785     for (Standard_Size i = 0; i < Length(); i++)
786       const_cast <gp_XYZ&> (aResult->Values()[i]) = Values()[i];
787   }
788   return aResult;
789 }
790
791 //=======================================================================
792 //function : VrmlData_Color::Read
793 //purpose  : 
794 //=======================================================================
795
796 VrmlData_ErrorStatus VrmlData_Color::Read (VrmlData_InBuffer& theBuffer)
797 {
798   return ReadArray (theBuffer, "color", Standard_False);
799 }
800
801 //=======================================================================
802 //function : VrmlData_Color::Write
803 //purpose  : 
804 //=======================================================================
805
806 VrmlData_ErrorStatus VrmlData_Color::Write (const char * thePrefix) const
807 {
808   static char header[] = "Color {";
809   VrmlData_ErrorStatus aStatus;
810   if (OK (aStatus, Scene().WriteLine (thePrefix, header, GlobalIndent())))
811   {
812     WriteArray ("color", Standard_False);
813     aStatus = WriteClosing();
814   }
815   return aStatus;
816 }
817
818 //=======================================================================
819 //function : VrmlData_Normal::Clone
820 //purpose  : 
821 //=======================================================================
822
823 Handle(VrmlData_Node) VrmlData_Normal::Clone
824                                 (const Handle(VrmlData_Node)& theOther) const
825 {
826   Handle(VrmlData_Normal) aResult =
827     Handle(VrmlData_Normal)::DownCast (VrmlData_Node::Clone(theOther));
828   if (aResult.IsNull())
829     aResult= new VrmlData_Normal(theOther.IsNull()? Scene() : theOther->Scene(),
830                                  Name());
831   if (&aResult->Scene() == &Scene())
832     aResult->SetValues (Length(), Values());
833   else {
834     aResult->AllocateValues (Length());
835     for (Standard_Size i = 0; i < Length(); i++)
836       const_cast <gp_XYZ&> (aResult->Values()[i]) = Values()[i];
837   }
838   return aResult;
839 }
840
841 //=======================================================================
842 //function : VrmlData_Normal::Read
843 //purpose  : 
844 //=======================================================================
845
846 VrmlData_ErrorStatus VrmlData_Normal::Read (VrmlData_InBuffer& theBuffer)
847 {
848   return VrmlData_ArrayVec3d::ReadArray (theBuffer, "vector", Standard_False);
849 }
850
851 //=======================================================================
852 //function : VrmlData_Normal::Write
853 //purpose  : 
854 //=======================================================================
855
856 VrmlData_ErrorStatus VrmlData_Normal::Write (const char * thePrefix) const
857 {
858   static char header[] = "Normal {";
859   VrmlData_ErrorStatus aStatus;
860   if (OK (aStatus, Scene().WriteLine (thePrefix, header, GlobalIndent())))
861   {
862     WriteArray ("vector", Standard_False);
863     aStatus = WriteClosing();
864   }
865   return aStatus;
866 }