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