0023316: OpenGl package can not be compiled on RedHat40-64
[occt.git] / src / OpenGl / OpenGl_PrimitiveArray.cxx
1 // Created on: 2011-07-13
2 // Created by: Sergey ZERCHANINOV
3 // Copyright (c) 2011-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 #include <OpenGl_IndexBuffer.hxx>
22 #include <OpenGl_Context.hxx>
23
24 #include <OpenGl_PrimitiveArray.hxx>
25
26 #include <OpenGl_AspectFace.hxx>
27 #include <OpenGl_GraphicDriver.hxx>
28 #include <OpenGl_Structure.hxx>
29 #include <OpenGl_TextureBox.hxx>
30
31 #include <InterfaceGraphic_PrimitiveArray.hxx>
32
33 namespace
34 {
35   static unsigned long vRand = 1L;
36   #define OGL_Rand() (vRand = vRand * 214013L + 2531011L)
37 };
38
39 // =======================================================================
40 // function : clearMemoryOwn
41 // purpose  :
42 // =======================================================================
43 void OpenGl_PrimitiveArray::clearMemoryOwn() const
44 {
45   Standard::Free ((Standard_Address& )myPArray->edges);
46   Standard::Free ((Standard_Address& )myPArray->vertices);
47   Standard::Free ((Standard_Address& )myPArray->vcolours);
48   Standard::Free ((Standard_Address& )myPArray->vnormals);
49   Standard::Free ((Standard_Address& )myPArray->vtexels);
50   Standard::Free ((Standard_Address& )myPArray->edge_vis); /// ???
51
52   myPArray->edges    = NULL;
53   myPArray->vertices = NULL;
54   myPArray->vcolours = NULL;
55   myPArray->vnormals = NULL;
56   myPArray->vtexels  = NULL;
57   myPArray->edge_vis = NULL;
58 }
59
60 // =======================================================================
61 // function : clearMemoryGL
62 // purpose  :
63 // =======================================================================
64 void OpenGl_PrimitiveArray::clearMemoryGL (const Handle(OpenGl_Context)& theGlCtx) const
65 {
66   for (Standard_Integer anIter = 0; anIter < VBOMaxType; ++anIter)
67   {
68     if (!myVbos[anIter].IsNull())
69     {
70       myVbos[anIter]->Release (theGlCtx.operator->());
71       myVbos[anIter].Nullify();
72     }
73   }
74 }
75
76 // =======================================================================
77 // function : BuildVBO
78 // purpose  :
79 // =======================================================================
80 Standard_Boolean OpenGl_PrimitiveArray::BuildVBO (const Handle(OpenGl_Workspace)& theWorkspace) const
81 {
82   const Handle(OpenGl_Context)& aGlCtx = theWorkspace->GetGlContext();
83   if (myPArray->vertices == NULL)
84   {
85     // vertices should be always defined - others are optional
86     return Standard_False;
87   }
88   myVbos[VBOVertices] = new OpenGl_VertexBuffer();
89   if (!myVbos[VBOVertices]->Init (aGlCtx, 3, myPArray->num_vertexs, &myPArray->vertices[0].xyz[0]))
90   {
91     clearMemoryGL (aGlCtx);
92     return Standard_False;
93   }
94
95   if (myPArray->edges != NULL)
96   {
97     myVbos[VBOEdges] = new OpenGl_IndexBuffer();
98     if (!myVbos[VBOEdges]->Init (aGlCtx, 1, myPArray->num_edges, (GLuint* )myPArray->edges))
99     {
100       clearMemoryGL (aGlCtx);
101       return Standard_False;
102     }
103   }
104   if (myPArray->vcolours != NULL)
105   {
106     myVbos[VBOVcolours] = new OpenGl_VertexBuffer();
107     if (!myVbos[VBOVcolours]->Init (aGlCtx, 4, myPArray->num_vertexs, (GLubyte* )myPArray->vcolours))
108     {
109       clearMemoryGL (aGlCtx);
110       return Standard_False;
111     }
112   }
113   if (myPArray->vnormals != NULL)
114   {
115     myVbos[VBOVnormals] = new OpenGl_VertexBuffer();
116     if (!myVbos[VBOVnormals]->Init (aGlCtx, 3, myPArray->num_vertexs, &myPArray->vnormals[0].xyz[0]))
117     {
118       clearMemoryGL (aGlCtx);
119       return Standard_False;
120     }
121   }
122   if (myPArray->vtexels)
123   {
124     myVbos[VBOVtexels] = new OpenGl_VertexBuffer();
125     if (!myVbos[VBOVtexels]->Init (aGlCtx, 2, myPArray->num_vertexs, &myPArray->vtexels[0].xy[0]))
126     {
127       clearMemoryGL (aGlCtx);
128       return Standard_False;
129     }
130   }
131
132   clearMemoryOwn();
133   return Standard_True;
134 }
135
136 // =======================================================================
137 // function : DrawArray
138 // purpose  :
139 // =======================================================================
140 void OpenGl_PrimitiveArray::DrawArray (Tint theLightingModel,
141                                        const Aspect_InteriorStyle theInteriorStyle,
142                                        Tint theEdgeFlag,
143                                        const TEL_COLOUR* theInteriorColour,
144                                        const TEL_COLOUR* theLineColour,
145                                        const TEL_COLOUR* theEdgeColour,
146                                        const OPENGL_SURF_PROP* theFaceProp,
147                                        const Handle(OpenGl_Workspace)& theWorkspace) const
148 {
149   const Handle(OpenGl_Context)& aGlContext = theWorkspace->GetGlContext();
150
151   Tint i,n;
152   Tint transp = 0;
153   // Following pointers have been provided for performance improvement
154   tel_colour pfc = myPArray->fcolours;
155   Tint* pvc = myPArray->vcolours;
156   if (pvc != NULL)
157   {
158     for (i = 0; i < myPArray->num_vertexs; ++i)
159     {
160       transp = int(theFaceProp->trans * 255.0f);
161     #if defined (sparc) || defined (__sparc__) || defined (__sparc) 
162       pvc[i] = (pvc[i] & 0xffffff00);
163       pvc[i] += transp;
164     #else     
165       pvc[i] = (pvc[i] & 0x00ffffff);
166       pvc[i] += transp << 24;
167     #endif
168     }
169   }
170
171   switch (myPArray->type)
172   {
173     case TelPointsArrayType:
174     case TelPolylinesArrayType:
175     case TelSegmentsArrayType:
176       glColor3fv (theLineColour->rgb);
177       break;
178     case TelPolygonsArrayType:
179     case TelTrianglesArrayType:
180     case TelQuadranglesArrayType:
181     case TelTriangleStripsArrayType:
182     case TelQuadrangleStripsArrayType:
183     case TelTriangleFansArrayType:
184       glColor3fv (theInteriorColour->rgb);
185       break;
186   }
187
188   // Temporarily disable environment mapping
189   if (myDrawMode <= GL_LINE_STRIP)
190   {
191     glPushAttrib (GL_ENABLE_BIT);
192     glDisable (GL_TEXTURE_1D);
193     glDisable (GL_TEXTURE_2D);
194   }
195
196   if (theWorkspace->DegenerateModel < 2 &&
197      ((myDrawMode >  GL_LINE_STRIP && theInteriorStyle != Aspect_IS_EMPTY) ||
198       (myDrawMode <= GL_LINE_STRIP)))
199   {
200     if (theWorkspace->NamedStatus & OPENGL_NS_HIGHLIGHT)
201     {
202       pfc = NULL;
203       pvc = NULL;
204     }
205
206     if (theInteriorStyle == Aspect_IS_HIDDENLINE)
207     {
208       theEdgeFlag = 1;
209       pfc = NULL;
210       pvc = NULL;
211     }
212
213     // Sometimes the GL_LIGHTING mode is activated here
214     // without glEnable(GL_LIGHTING) call for an unknown reason, so it is necessary 
215     // to call glEnable(GL_LIGHTING) to synchronize Light On/Off mechanism*
216     if (theLightingModel == 0 || myDrawMode <= GL_LINE_STRIP)
217       glDisable (GL_LIGHTING);
218     else
219       glEnable (GL_LIGHTING);
220
221     if (!toDrawVbo())
222     {
223       if (myPArray->vertices != NULL)
224       {
225         glVertexPointer (3, GL_FLOAT, 0, myPArray->vertices); // array of vertices
226         glEnableClientState (GL_VERTEX_ARRAY);
227       }
228       if (myPArray->vnormals != NULL)
229       {
230         glNormalPointer (GL_FLOAT, 0, myPArray->vnormals); // array of normals
231         glEnableClientState (GL_NORMAL_ARRAY);
232       }
233       if (myPArray->vtexels != NULL)
234       {
235         glTexCoordPointer (2, GL_FLOAT, 0, myPArray->vtexels); // array of texture coordinates
236         glEnableClientState (GL_TEXTURE_COORD_ARRAY);
237       }
238
239       if (pvc != NULL)
240       {
241         glColorPointer (4, GL_UNSIGNED_BYTE, 0, pvc);  // array of colors
242         glEnableClientState (GL_COLOR_ARRAY);
243         glColorMaterial (GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE);
244         glEnable (GL_COLOR_MATERIAL);
245       }
246     }
247     else
248     {
249       // Bindings concrete pointer in accordance with VBO buffer
250       myVbos[VBOVertices]->BindFixed (aGlContext, GL_VERTEX_ARRAY);
251       if (!myVbos[VBOVnormals].IsNull())
252       {
253         myVbos[VBOVnormals]->BindFixed (aGlContext, GL_NORMAL_ARRAY);
254       }
255       if (!myVbos[VBOVtexels].IsNull() && (theWorkspace->NamedStatus & OPENGL_NS_FORBIDSETTEX) == 0)
256       {
257         myVbos[VBOVtexels]->BindFixed (aGlContext, GL_TEXTURE_COORD_ARRAY);
258       }
259       if (!myVbos[VBOVcolours].IsNull())
260       {
261         myVbos[VBOVcolours]->BindFixed (aGlContext, GL_COLOR_ARRAY);
262         glColorMaterial (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
263         glEnable (GL_COLOR_MATERIAL);
264       }
265     }
266
267     /// OCC22236 NOTE: draw for all situations:
268     /// 1) draw elements from myPArray->bufferVBO[VBOEdges] indicies array
269     /// 2) draw elements from vertice array, when bounds defines count of primitive's verts.
270     /// 3) draw primitive by vertexes if no edges and bounds array is specified
271     if (toDrawVbo())
272     {
273       if (!myVbos[VBOEdges].IsNull())
274       {
275         myVbos[VBOEdges]->Bind (aGlContext);
276         if (myPArray->num_bounds > 0)
277         {
278           // draw primitives by vertex count with the indicies
279           Tint* anOffset = NULL;
280           for (i = 0; i < myPArray->num_bounds; ++i)
281           {
282             glDrawElements (myDrawMode, myPArray->bounds[i], myVbos[VBOEdges]->GetDataType(), anOffset);
283             anOffset += myPArray->bounds[i]; 
284           }
285         }
286         else
287         {
288           // draw one (or sequential) primitive by the indicies
289           glDrawElements (myDrawMode, myPArray->num_edges, myVbos[VBOEdges]->GetDataType(), NULL);
290         }
291         myVbos[VBOEdges]->Unbind (aGlContext);
292       }
293       else if (myPArray->num_bounds > 0)
294       {
295         for (i = n = 0; i < myPArray->num_bounds; ++i)
296         {
297           glDrawArrays (myDrawMode, n, myPArray->bounds[i]);
298           n += myPArray->bounds[i];
299         }
300       }
301       else
302       {
303         glDrawArrays (myDrawMode, 0, myVbos[VBOVertices]->GetElemsNb());
304       }
305
306       // bind with 0
307       myVbos[VBOVertices]->UnbindFixed (aGlContext, GL_VERTEX_ARRAY);
308       if (!myVbos[VBOVnormals].IsNull())
309       {
310         myVbos[VBOVnormals]->UnbindFixed (aGlContext, GL_NORMAL_ARRAY);
311       }
312       if (!myVbos[VBOVtexels].IsNull() && (theWorkspace->NamedStatus & OPENGL_NS_FORBIDSETTEX) == 0)
313       {
314         myVbos[VBOVtexels]->UnbindFixed (aGlContext, GL_TEXTURE_COORD_ARRAY);
315       }
316       if (!myVbos[VBOVcolours].IsNull())
317       {
318         myVbos[VBOVcolours]->UnbindFixed (aGlContext, GL_COLOR_ARRAY);
319         glDisable (GL_COLOR_MATERIAL);
320         theWorkspace->NamedStatus |= OPENGL_NS_RESMAT; // Reset material
321       }
322     } 
323     else
324     {
325       if (myPArray->num_bounds > 0)
326       {
327         if (myPArray->num_edges > 0)
328         {
329           for (i = n = 0; i < myPArray->num_bounds; ++i)
330           {
331             if (pfc != NULL) glColor3fv (pfc[i].rgb);
332             glDrawElements (myDrawMode, myPArray->bounds[i], GL_UNSIGNED_INT, (GLenum* )&myPArray->edges[n]);
333             n += myPArray->bounds[i];
334           }
335         }
336         else
337         {
338           for (i = n = 0; i < myPArray->num_bounds; ++i)
339           {
340             if (pfc != NULL)
341             {
342               glColor3fv (pfc[i].rgb);
343             }
344             glDrawArrays (myDrawMode, n, myPArray->bounds[i]);
345             n += myPArray->bounds[i];
346           }
347         }
348       }
349       else if (myPArray->num_edges > 0)
350       {
351         glDrawElements (myDrawMode, myPArray->num_edges, GL_UNSIGNED_INT, (GLenum* )myPArray->edges);
352       }
353       else
354       {
355         glDrawArrays (myDrawMode, 0, myPArray->num_vertexs);
356       }
357
358       if (pvc != NULL)
359       {
360         glDisable (GL_COLOR_MATERIAL);
361         theWorkspace->NamedStatus |= OPENGL_NS_RESMAT; // Reset material
362       }
363
364       glDisableClientState (GL_VERTEX_ARRAY);
365       if (myPArray->vcolours != NULL)
366         glDisableClientState (GL_COLOR_ARRAY);
367       if (myPArray->vnormals != NULL)
368         glDisableClientState (GL_NORMAL_ARRAY);
369       if (myPArray->vtexels != NULL)
370         glDisableClientState (GL_TEXTURE_COORD_ARRAY);
371     }
372
373     if (theWorkspace->DegenerateModel)
374     {
375       if (myDrawMode <= GL_LINE_STRIP)
376       {
377         glPopAttrib();
378       }
379       return;
380     }
381   }
382
383   if (theEdgeFlag || theWorkspace->DegenerateModel)
384   {
385     switch (theWorkspace->DegenerateModel)
386     {
387       default: // XXX_TDM_NODE or TINY
388         //  On some NVIDIA graphic cards, using glEdgeFlagPointer() in 
389         //  combination with VBO ( edge flag data put into a VBO buffer)
390         //  leads to a crash in a driver. Therefore, edge flags are simply 
391         //  igonored when VBOs are enabled, so all the edges are drawn if 
392         //  edge visibility is turned on. In order to draw edges selectively, 
393         //  either disable VBO or turn off edge visibilty in the current 
394         //  primitive array and create a separate primitive array (segments) 
395         //  and put edges to be drawn into it.
396         if (myDrawMode > GL_LINE_STRIP)
397         {
398           DrawEdges (theEdgeFlag ? theEdgeColour : theInteriorColour, theWorkspace);
399         }
400         break;
401       // DegenerateModel(as Lines, Points, BBoxs) are used only without VBO
402       case 2: // XXX_TDM_WIREFRAME
403         if (!toDrawVbo())
404           DrawDegeneratesAsLines ((theEdgeFlag ? theEdgeColour : theInteriorColour), theWorkspace);
405         break;
406       case 3: // XXX_TDM_MARKER
407         if (!toDrawVbo())
408           DrawDegeneratesAsPoints ((theEdgeFlag ? theEdgeColour : theInteriorColour), theWorkspace->SkipRatio);
409         break;
410       case 4: // XXX_TDM_BBOX
411         if (!toDrawVbo())
412           DrawDegeneratesAsBBoxs (theEdgeFlag ? theEdgeColour : theInteriorColour);
413         break;
414     }
415   }
416
417   if (myDrawMode <= GL_LINE_STRIP)
418     glPopAttrib();
419 }
420
421 // =======================================================================
422 // function : DrawEdges
423 // purpose  :
424 // =======================================================================
425 void OpenGl_PrimitiveArray::DrawEdges (const TEL_COLOUR*               theEdgeColour,
426                                        const Handle(OpenGl_Workspace)& theWorkspace) const
427 {
428   glDisable (GL_LIGHTING);
429
430   const Handle(OpenGl_Context)& aGlContext = theWorkspace->GetGlContext();
431   const OpenGl_AspectLine* anAspectLineOld = NULL;
432   if (myDrawMode > GL_LINE_STRIP)
433   {
434     anAspectLineOld = theWorkspace->SetAspectLine (theWorkspace->AspectFace (Standard_True)->AspectEdge());
435     theWorkspace->AspectLine (Standard_True);
436
437     glPushAttrib (GL_POLYGON_BIT);
438     glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
439   }
440
441   Tint i, j, n;
442
443   /// OCC22236 NOTE: draw edges for all situations:
444   /// 1) draw elements with GL_LINE style as edges from myPArray->bufferVBO[VBOEdges] indicies array
445   /// 2) draw elements from vertice array, when bounds defines count of primitive's verts.
446   /// 3) draw primitive's edges by vertexes if no edges and bounds array is specified
447   if (toDrawVbo())
448   { 
449     myVbos[VBOVertices]->BindFixed (aGlContext, GL_VERTEX_ARRAY);
450     glColor3fv (theEdgeColour->rgb);
451     if (!myVbos[VBOEdges].IsNull())
452     {
453       myVbos[VBOEdges]->Bind (aGlContext);
454
455       // draw primitives by vertex count with the indicies
456       if (myPArray->num_bounds > 0)
457       {
458         Tint* offset = 0;
459         for (i = 0, offset = 0; i < myPArray->num_bounds; ++i)
460         {
461           glDrawElements (myDrawMode, myPArray->bounds[i], myVbos[VBOEdges]->GetDataType(), offset);
462           offset += myPArray->bounds[i];
463         }
464       }
465       // draw one (or sequential) primitive by the indicies
466       else
467       {
468         glDrawElements (myDrawMode, myVbos[VBOEdges]->GetElemsNb(), myVbos[VBOEdges]->GetDataType(), NULL);
469       }
470       myVbos[VBOEdges]->Unbind (aGlContext);
471     }
472     else if (myPArray->num_bounds > 0)
473     {
474       for (i = n = 0; i < myPArray->num_bounds; ++i)
475       {
476         glDrawArrays (myDrawMode, n, myPArray->bounds[i]);
477         n += myPArray->bounds[i];
478       }
479     }
480     else
481     {
482       glDrawArrays (myDrawMode, 0, myPArray->num_vertexs);
483     }
484
485     // unbind buffers
486     myVbos[VBOVertices]->UnbindFixed (aGlContext, GL_VERTEX_ARRAY);
487   }
488   else
489   {
490     glEnableClientState (GL_VERTEX_ARRAY);
491     glVertexPointer (3, GL_FLOAT, 0, myPArray->vertices); // array of vertices
492
493     glColor3fv (theEdgeColour->rgb);
494     if (myPArray->num_bounds > 0)
495     {
496       if (myPArray->num_edges > 0)
497       {
498         for (i = n = 0; i < myPArray->num_bounds; ++i)
499         {
500           if (myPArray->edge_vis)
501           {
502             glBegin (myDrawMode);
503             for (j = 0; j < myPArray->bounds[i]; ++j)
504             {
505               glEdgeFlag (myPArray->edge_vis[n+j]);
506               glVertex3fv (&myPArray->vertices[myPArray->edges[n+j]].xyz[0]);
507             }
508             glEnd();
509           }
510           else
511           {
512             glDrawElements (myDrawMode, myPArray->bounds[i], GL_UNSIGNED_INT, (GLenum* )&myPArray->edges[n]);
513           }
514           n += myPArray->bounds[i];
515         }
516       }
517       else
518       {
519         for (i = n = 0 ; i < myPArray->num_bounds; ++i)
520         {
521           glDrawArrays (myDrawMode, n, myPArray->bounds[i]);
522           n += myPArray->bounds[i];
523         }
524       }
525     } 
526     else if (myPArray->num_edges > 0)
527     {
528       if (myPArray->edge_vis)
529       {
530         glBegin (myDrawMode);
531         for (i = 0; i < myPArray->num_edges; ++i)
532         {
533           glEdgeFlag (myPArray->edge_vis[i]);
534           glVertex3fv (&myPArray->vertices[myPArray->edges[i]].xyz[0]);
535         }
536         glEnd();
537       }
538       else
539       {
540         glDrawElements (myDrawMode, myPArray->num_edges, GL_UNSIGNED_INT, (GLenum* )myPArray->edges);
541       }
542     }
543     else
544     {
545       glDrawArrays (myDrawMode, 0, myPArray->num_vertexs);
546     }
547   }
548
549   if (myDrawMode > GL_LINE_STRIP)
550   {
551     // Restore line context
552     theWorkspace->SetAspectLine (anAspectLineOld);
553     glPopAttrib();
554   }
555 }
556
557 // =======================================================================
558 // function : DrawDegeneratesPointsAsPoints
559 // purpose  :
560 // =======================================================================
561 void OpenGl_PrimitiveArray::DrawDegeneratesPointsAsPoints() const
562
563   tel_point pv = myPArray->vertices;
564   for (Tint aVertId = 0; aVertId < myPArray->num_vertexs; ++aVertId)
565   {
566     glVertex3fv (&pv[aVertId].xyz[0]);
567   }
568 }
569
570 // =======================================================================
571 // function : DrawDegeneratesLinesAsPoints
572 // purpose  :
573 // =======================================================================
574 void OpenGl_PrimitiveArray::DrawDegeneratesLinesAsPoints() const
575 {
576   GLfloat pt[3];
577   tel_point pv = myPArray->vertices;
578
579   Tint j = 0;
580   while (j < myPArray->num_vertexs)
581   {
582     pt[0] = pv[j].xyz[0];
583     pt[1] = pv[j].xyz[1];
584     pt[2] = pv[j].xyz[2]; ++j;
585     pt[0] += pv[j].xyz[0];
586     pt[1] += pv[j].xyz[1];
587     pt[2] += pv[j].xyz[2]; ++j;
588     pt[0] *= 0.5f;
589     pt[1] *= 0.5f;
590     pt[2] *= 0.5f;
591     glVertex3fv (pt);
592   }
593 }  
594
595 // =======================================================================
596 // function : DrawDegeneratesTrianglesAsPoints
597 // purpose  :
598 // =======================================================================
599 void OpenGl_PrimitiveArray::DrawDegeneratesTrianglesAsPoints() const
600 {
601   Tint      i, j, iv;
602   GLfloat   pt[ 3 ];
603   tel_point pv = myPArray->vertices;
604
605   if (myPArray->num_edges > 0)
606   {
607     for (j = 0; j < myPArray->num_edges; j += 3)
608     {
609       iv = myPArray->edges[j];
610       pt[0] = pv[iv].xyz[0];
611       pt[1] = pv[iv].xyz[1];
612       pt[2] = pv[iv].xyz[2];
613       for (i = 1; i < 3; ++i)
614       {
615         iv = myPArray->edges[j+i];
616         pt[0] += pv[iv].xyz[0];
617         pt[1] += pv[iv].xyz[1];
618         pt[2] += pv[iv].xyz[2];
619       }
620       pt[0] /= 3.f;
621       pt[1] /= 3.f;
622       pt[2] /= 3.f;
623       glVertex3fv (pt);
624     }
625   }
626   else
627   {
628     for (j = 0; j < myPArray->num_vertexs; j += 3)
629     {
630       pt[0] = pv[j].xyz[0];
631       pt[1] = pv[j].xyz[1];
632       pt[2] = pv[j].xyz[2];
633       for (i = 1; i < 3; ++i)
634       {
635         pt[0] += pv[j+i].xyz[0];
636         pt[1] += pv[j+i].xyz[1];
637         pt[2] += pv[j+i].xyz[2];
638       }
639       pt[0] /= 3.f;
640       pt[1] /= 3.f;
641       pt[2] /= 3.f;
642       glVertex3fv (pt);
643     }
644   }
645 }
646
647 // =======================================================================
648 // function : DrawDegeneratesTrianglesAsPoints
649 // purpose  :
650 // =======================================================================
651 void OpenGl_PrimitiveArray::DrawDegeneratesTrianglestripsAsPoints() const
652
653   Tint      i, j, k, n;
654   GLfloat   pt[ 3 ];
655   tel_point pv = myPArray->vertices;
656
657   if (myPArray->num_bounds > 0)
658   {
659     for (k = n = 0; k < myPArray->num_bounds; ++k)
660     {
661       for (j = 0; j < myPArray->bounds[k] - 2; ++j)
662       {
663         pt[0] = pv[n+j].xyz[0];
664         pt[1] = pv[n+j].xyz[1];
665         pt[2] = pv[n+j].xyz[2];
666         for (i = 1; i < 3; ++i)
667         {
668           pt[0] += pv[n+j+i].xyz[0];
669           pt[1] += pv[n+j+i].xyz[1];
670           pt[2] += pv[n+j+i].xyz[2];
671         }
672         pt[0] /= 3.f;
673         pt[1] /= 3.f;
674         pt[2] /= 3.f;
675         glVertex3fv (pt);
676       }
677       n += myPArray->bounds[k];
678     }
679   }
680   else
681   {
682     for (j = 0; j < myPArray->num_vertexs - 2; ++j)
683     {
684       pt[0] = pv[j].xyz[0];
685       pt[1] = pv[j].xyz[1];
686       pt[2] = pv[j].xyz[2];
687       for (i = 1; i < 3; ++i)
688       {
689         pt[0] += pv[j+i].xyz[0];
690         pt[1] += pv[j+i].xyz[1];
691         pt[2] += pv[j+i].xyz[2];
692       }
693       pt[0] /= 3.f;
694       pt[1] /= 3.f;
695       pt[2] /= 3.f;
696       glVertex3fv (pt);
697     }
698   }
699 }
700
701 // =======================================================================
702 // function : DrawDegeneratesPolygonsAsPoints
703 // purpose  :
704 // =======================================================================
705 void OpenGl_PrimitiveArray::DrawDegeneratesPolygonsAsPoints() const
706
707   Tint      j, k, n, iv;
708   GLfloat   pt[3];
709   tel_point pv = myPArray->vertices;
710
711   if (myPArray->num_bounds > 0)
712   {
713     if (myPArray->num_edges > 0)
714     {
715       for (k = n = 0; k < myPArray->num_bounds; ++k)
716       {
717         pt[0] = pt[1] = pt[2] = 0.0;
718         for (j = 0; j < myPArray->bounds[k]; ++j)
719         {
720           iv = myPArray->edges[n+j];
721           pt[0] += pv[iv].xyz[0];
722           pt[1] += pv[iv].xyz[1];
723           pt[2] += pv[iv].xyz[2];
724         }
725         pt[0] /= myPArray->bounds[k];
726         pt[1] /= myPArray->bounds[k];
727         pt[2] /= myPArray->bounds[k];
728         glVertex3fv (pt);
729         n += myPArray->bounds[k];
730       }
731     }
732     else
733     {
734       for (k = n = 0; k < myPArray->num_bounds; ++k)
735       {
736         pt[0] = pt[1] = pt[2] = 0.0;
737         for (j = 0; j < myPArray->bounds[k]; ++j)
738         {
739           pt[0] += pv[n+j].xyz[0];
740           pt[1] += pv[n+j].xyz[1];
741           pt[2] += pv[n+j].xyz[2];
742         }
743         pt[0] /= myPArray->bounds[k];
744         pt[1] /= myPArray->bounds[k];
745         pt[2] /= myPArray->bounds[k];
746         glVertex3fv (pt);
747         n += myPArray->bounds[k];
748       }
749     }
750   }
751   else if (myPArray->num_edges > 0)
752   {
753     pt[0] = pt[1] = pt[2] = 0.0;
754     for (j = 0; j < myPArray->num_edges; ++j)
755     {
756       iv = myPArray->edges[j];
757       pt[0] += pv[iv].xyz[0];
758       pt[1] += pv[iv].xyz[1];
759       pt[2] += pv[iv].xyz[2];
760     }
761     pt[0] /= myPArray->num_edges;
762     pt[1] /= myPArray->num_edges;
763     pt[2] /= myPArray->num_edges;
764     glVertex3fv (pt);
765   }
766   else
767   {
768     pt[0] = pt[1] = pt[2] = 0.0;
769     for (j = 0; j < myPArray->num_vertexs; ++j)
770     {
771       pt[0] += pv[j].xyz[0];
772       pt[1] += pv[j].xyz[1];
773       pt[2] += pv[j].xyz[2];
774     }
775     pt[0] /= myPArray->num_vertexs;
776     pt[1] /= myPArray->num_vertexs;
777     pt[2] /= myPArray->num_vertexs;
778     glVertex3fv (pt);
779   }
780 }
781
782 // =======================================================================
783 // function : DrawDegeneratesQuadranglesAsPoints
784 // purpose  :
785 // =======================================================================
786 void OpenGl_PrimitiveArray::DrawDegeneratesQuadranglesAsPoints() const
787 {
788   Tint      i, j, iv;
789   GLfloat   pt[ 3 ];
790   tel_point pv = myPArray->vertices;
791
792   if (myPArray->num_edges > 0)
793   {
794     for (j = 0; j < myPArray->num_edges; j += 4)
795     {
796       pt[0] = pt[1] = pt[2] = 0.0;
797       for (i = 0; i < 4; ++i)
798       {
799         iv = myPArray->edges[j+i];
800         pt[0] += pv[iv].xyz[0];
801         pt[1] += pv[iv].xyz[1];
802         pt[2] += pv[iv].xyz[2];
803       }
804       pt[0] /= 4;
805       pt[1] /= 4;
806       pt[2] /= 4;
807       glVertex3fv ( pt );
808     }
809   }
810   else
811   {
812     for (j = 0; j < myPArray->num_vertexs; j += 4)
813     {
814       pt[0] = pt[1] = pt[2] = 0.0;
815       for (i = 0; i < 4; ++i)
816       {
817         pt[0] += pv[j+i].xyz[0];
818         pt[1] += pv[j+i].xyz[1];
819         pt[2] += pv[j+i].xyz[2];
820       }
821       pt[0] /= 4;
822       pt[1] /= 4;
823       pt[2] /= 4;
824       glVertex3fv (pt);
825     }
826   }
827 }  
828
829 // =======================================================================
830 // function : DrawDegeneratesAsPoints
831 // purpose  :
832 // =======================================================================
833 void OpenGl_PrimitiveArray::DrawDegeneratesQuadranglestripsAsPoints() const
834
835   Tint      i, j, k, n;
836   GLfloat   pt[3];
837   tel_point pv = myPArray->vertices;
838
839   if (myPArray->num_bounds > 0)
840   {
841     for (k = n = 0; k < myPArray->num_bounds; ++k)
842     {
843       for (j = 0; j < myPArray->bounds[k] - 2; j += 2)
844       {
845         pt[0] = pt[1] = pt[2] = 0.;
846         for (i = 0; i < 4; ++i)
847         {
848           pt[0] += pv[n+j+i].xyz[0];
849           pt[1] += pv[n+j+i].xyz[1];
850           pt[2] += pv[n+j+i].xyz[2];
851         }
852         pt[0] /= 4;
853         pt[1] /= 4;
854         pt[2] /= 4;
855         glVertex3fv (pt);
856       }
857       n += myPArray->bounds[k];
858     }
859   }
860   else
861   {
862     for (j = 0; j < myPArray->num_vertexs - 2; j += 2)
863     {
864       pt[0] = pt[1] = pt[2] = 0.;
865       for (i = 0; i < 4; ++i)
866       {
867         pt[0] += pv[j+i].xyz[0];
868         pt[1] += pv[j+i].xyz[1];
869         pt[2] += pv[j+i].xyz[2];
870       }
871       pt[0] /= 4;
872       pt[1] /= 4;
873       pt[2] /= 4;
874       glVertex3fv (pt);
875     }
876   }
877 }
878
879 // =======================================================================
880 // function : DrawDegeneratesAsPoints
881 // purpose  :
882 // =======================================================================
883 void OpenGl_PrimitiveArray::DrawDegeneratesAsPoints (const TEL_COLOUR* theEdgeColour,
884                                                      const float       theSkipRatio) const
885 {
886   if (theSkipRatio >= 1.0f)
887     return;
888
889   GLboolean zbuff_state = glIsEnabled (GL_DEPTH_TEST);
890   glDisable (GL_LIGHTING);
891   if (zbuff_state)
892     glDisable (GL_DEPTH_TEST); 
893   glColor3fv (theEdgeColour->rgb);
894
895   glBegin (GL_POINTS);
896   switch (myDrawMode)
897   {
898     case GL_POINTS:
899       DrawDegeneratesPointsAsPoints();
900       break;
901     case GL_LINES:
902       DrawDegeneratesLinesAsPoints();
903       break;
904     case GL_LINE_STRIP:
905     case GL_POLYGON:
906       DrawDegeneratesPolygonsAsPoints();
907       break;
908     case GL_TRIANGLES:
909       DrawDegeneratesTrianglesAsPoints();
910       break;
911     case GL_QUADS:
912       DrawDegeneratesQuadranglesAsPoints();
913       break;
914     case GL_TRIANGLE_FAN:
915     case GL_TRIANGLE_STRIP:
916       DrawDegeneratesTrianglestripsAsPoints();
917       break;
918     case GL_QUAD_STRIP:
919       DrawDegeneratesQuadranglestripsAsPoints();
920       break;
921     default:
922       break;
923   }
924   glEnd();
925   if (zbuff_state)
926     glEnable (GL_DEPTH_TEST);
927 }
928
929 // =======================================================================
930 // function : DrawDegeneratesLinesAsLines
931 // purpose  :
932 // =======================================================================
933 void OpenGl_PrimitiveArray::DrawDegeneratesLinesAsLines (const float theSkipRatio) const
934 {
935   Tint i, iv;
936   tel_point  pv = myPArray->vertices;
937
938   Tint n = myPArray->num_vertexs;
939   Tint j = int((1.0f - theSkipRatio) * n);
940   for (; j > 0; --j)
941   {
942     i = OGL_Rand() % n;
943     myPArray->keys[i] = -myPArray->keys[i];
944   }
945
946   if (myPArray->num_bounds > 0)
947   {
948     if (myPArray->num_edges > 0)
949     {
950       for (i = n = 0; i < myPArray->num_bounds; ++i)
951       {
952         glBegin (GL_LINES);
953         for (j = 0; j < myPArray->bounds[i]; ++j)
954         {
955           iv = myPArray->edges[n + j];
956           if (myPArray->keys[iv] < 0)
957           {
958             myPArray->keys[iv] = -myPArray->keys[iv];
959             glVertex3fv (pv[iv].xyz);
960           }
961         }
962         glEnd();
963         n += myPArray->bounds[i];
964       }
965     }
966     else
967     {
968       for (i = n = 0; i < myPArray->num_bounds; ++i)
969       {
970         glBegin (GL_LINES);
971         for (j = 0; j < myPArray->bounds[i]; ++j)
972         {
973           if (myPArray->keys[n+j] < 0)
974           {
975             myPArray->keys[n+j] = -myPArray->keys[n+j];
976             glVertex3fv (pv[n+j].xyz);
977           }
978         }
979         glEnd();
980         n += myPArray->bounds[i];
981       }
982     }
983   }
984   else if (myPArray->num_edges > 0)
985   {
986     glBegin (GL_LINES);
987     for (j = 0; j < myPArray->num_edges; ++j)
988     {
989       iv = myPArray->edges[j];
990       if (myPArray->keys[iv] < 0)
991       {
992         myPArray->keys[iv] = -myPArray->keys[iv];
993         glVertex3fv (pv[iv].xyz);
994       }
995     }
996     glEnd();
997   }
998   else
999   {
1000     glBegin (GL_LINES);
1001     for (j = 0; j < myPArray->num_vertexs; ++j)
1002     {
1003       if (myPArray->keys[j] < 0)
1004       {
1005         myPArray->keys[j] = -myPArray->keys[j];
1006         glVertex3fv (pv[j].xyz);
1007       }
1008     }
1009     glEnd();
1010   }
1011 }
1012
1013 // =======================================================================
1014 // function : DrawDegeneratesTrianglesAsLines
1015 // purpose  :
1016 // =======================================================================
1017 void OpenGl_PrimitiveArray::DrawDegeneratesTrianglesAsLines (const float theSkipRatio) const
1018
1019   Tint i, iv;
1020   tel_point pv = myPArray->vertices;
1021
1022   Tint n = myPArray->num_vertexs / 3;
1023   Tint j = int((1.0f - theSkipRatio) * n);
1024   for (; j > 0; --j)
1025   {
1026     i = OGL_Rand() % n; i *= 3;
1027     myPArray->keys[i] = -myPArray->keys[i];
1028   }
1029
1030   if (myPArray->num_edges > 0)
1031   {
1032     for (j = 0; j < myPArray->num_edges; j += 3)
1033     {
1034       iv = myPArray->edges[j];
1035       if (myPArray->keys[iv] < 0)
1036       { 
1037         myPArray->keys[iv] = -myPArray->keys[iv];
1038         glBegin (GL_LINE_LOOP);
1039         for (i = 0; i < 3; ++i)
1040         {
1041           iv = myPArray->edges[j+i];
1042           glVertex3fv (pv[iv].xyz);
1043         }
1044         glEnd();
1045       }
1046     }
1047   }
1048   else
1049   {
1050     for (j = 0; j < myPArray->num_vertexs; j += 3)
1051     {
1052       if (myPArray->keys[j] < 0)
1053       {
1054         myPArray->keys[j] = -myPArray->keys[j];
1055         glBegin (GL_LINE_LOOP);
1056         for (i = 0; i < 3; ++i)
1057         {
1058           glVertex3fv (pv[j+i].xyz);
1059         }
1060         glEnd();
1061       }
1062     }
1063   }
1064 }
1065
1066 // =======================================================================
1067 // function : DrawDegeneratesTrianglesAsLines
1068 // purpose  :
1069 // =======================================================================
1070 void OpenGl_PrimitiveArray::DrawDegeneratesTrianglestripsAsLines (const float theSkipRatio) const
1071
1072   Tint i, j, k, n, ni;
1073   tel_point pv = myPArray->vertices;
1074
1075   if (myPArray->num_bounds > 0)
1076   {
1077     for (i = n = 0; i < myPArray->num_bounds; ++i)
1078     {
1079       ni = myPArray->bounds[i] - 2;
1080       k = int((1.0f - theSkipRatio) * ni);
1081       for (; k > 0; --k)
1082       {
1083         j = OGL_Rand() % ni; j += 2;
1084         myPArray->keys[n+j] = -myPArray->keys[n+j];
1085       }
1086       for (j = 2; j < myPArray->bounds[i]; ++j)
1087       {
1088         if (myPArray->keys[n+j] < 0)
1089         {
1090           myPArray->keys[n+j] = -myPArray->keys[n+j];
1091           glBegin (GL_LINE_LOOP);
1092           glVertex3fv (pv[n+j-2].xyz);
1093           glVertex3fv (pv[n+j-1].xyz);
1094           glVertex3fv (pv[n+j].xyz);
1095           glEnd();
1096         }
1097       }
1098       n += myPArray->bounds[i];
1099     }
1100   }
1101   else
1102   {
1103     ni = myPArray->num_vertexs - 2;
1104     k = int((1.0f - theSkipRatio) * ni);
1105     for (; k > 0; --k)
1106     {
1107       j = OGL_Rand() % ni; j += 2;
1108       myPArray->keys[j] = -myPArray->keys[j];
1109     }
1110     for (j = 2; j < myPArray->num_vertexs; ++j)
1111     {
1112       if (myPArray->keys[j] < 0)
1113       {
1114         myPArray->keys[j] = -myPArray->keys[j];
1115         glBegin (GL_LINE_LOOP);
1116         glVertex3fv (pv[j-2].xyz);
1117         glVertex3fv (pv[j-1].xyz);
1118         glVertex3fv (pv[j].xyz);
1119         glEnd();
1120       }
1121     }
1122   }
1123 }
1124
1125 // =======================================================================
1126 // function : DrawDegeneratesPolygonsAsLines
1127 // purpose  :
1128 // =======================================================================
1129 void OpenGl_PrimitiveArray::DrawDegeneratesPolygonsAsLines (const float theSkipRatio) const
1130
1131   Tint i, iv;
1132   tel_point pv = myPArray->vertices;
1133
1134   Tint n = myPArray->num_vertexs;
1135   Tint j = int((1.0f - theSkipRatio) * n);
1136   for (; j > 0; --j)
1137   {
1138     i = OGL_Rand() % n;
1139     myPArray->keys[i] = -myPArray->keys[i];
1140   }
1141
1142   if (myPArray->num_bounds > 0)
1143   {
1144     if (myPArray->num_edges > 0)
1145     {
1146       for (i = n = 0; i < myPArray->num_bounds; ++i)
1147       {
1148         glBegin (GL_LINE_LOOP);
1149         for (j = 0; j < myPArray->bounds[i]; ++j)
1150         {
1151           iv = myPArray->edges[n+j];
1152           if (myPArray->keys[iv] < 0)
1153           {
1154             myPArray->keys[iv] = -myPArray->keys[iv];
1155             glVertex3fv (pv[iv].xyz);
1156           }
1157         }
1158         glEnd();
1159         n += myPArray->bounds[i];
1160       }
1161     }
1162     else
1163     {
1164       for (i = n = 0; i < myPArray->num_bounds; ++i)
1165       {
1166         glBegin (GL_LINE_LOOP);
1167         for (j = 0; j < myPArray->bounds[i]; ++j)
1168         {
1169           if (myPArray->keys[n+j] < 0)
1170           {
1171             myPArray->keys[n+j] = -myPArray->keys[n+j];
1172             glVertex3fv (pv[n+j].xyz);
1173           }
1174         }
1175         glEnd();
1176         n += myPArray->bounds[i];
1177       }
1178     }
1179   }
1180   else if (myPArray->num_edges > 0)
1181   {
1182     glBegin (GL_LINE_LOOP);
1183     for (j = 0; j < myPArray->num_edges; ++j)
1184     {
1185       iv = myPArray->edges[j];
1186       if (myPArray->keys[iv] < 0)
1187       {
1188         myPArray->keys[iv] = -myPArray->keys[iv];
1189         glVertex3fv (pv[iv].xyz);
1190       }
1191     }
1192     glEnd();
1193   }
1194   else
1195   {
1196     glBegin (GL_LINE_LOOP);
1197     for (j = 0; j < myPArray->num_vertexs; ++j)
1198     {
1199       if (myPArray->keys[j] < 0)
1200       {
1201         myPArray->keys[j] = -myPArray->keys[j];
1202         glVertex3fv (pv[j].xyz);
1203       }
1204     }
1205     glEnd();
1206   }
1207 }  
1208
1209 // =======================================================================
1210 // function : DrawDegeneratesQuadranglesAsLines
1211 // purpose  :
1212 // =======================================================================
1213 void OpenGl_PrimitiveArray::DrawDegeneratesQuadranglesAsLines (const float theSkipRatio) const
1214 {
1215   Tint i, iv;
1216   tel_point pv = myPArray->vertices;
1217
1218   Tint n = myPArray->num_vertexs / 4;
1219   Tint j = int((1.0f - theSkipRatio) * n);
1220   for (; j > 0; --j)
1221   {
1222     i = OGL_Rand() % n; i *= 4;
1223     myPArray->keys[i] = -myPArray->keys[i];
1224   }
1225
1226   if (myPArray->num_edges > 0)
1227   {
1228     for (j = 0; j < myPArray->num_edges; j += 4)
1229     {
1230       iv = myPArray->edges[j];
1231       if (myPArray->keys[iv] < 0)
1232       {
1233         myPArray->keys[iv] = -myPArray->keys[iv];
1234         glBegin (GL_LINE_LOOP);
1235         for (i = 0; i < 4; ++i)
1236         {
1237           iv = myPArray->edges[j+i];
1238           glVertex3fv (pv[iv].xyz);
1239         }
1240         glEnd();
1241       }
1242     }
1243   }
1244   else
1245   {
1246     for (j = 0; j < myPArray->num_vertexs; j += 4)
1247     {
1248       if (myPArray->keys[j] < 0)
1249       {
1250         myPArray->keys[j] = -myPArray->keys[j];
1251         glBegin (GL_LINE_LOOP);
1252         for (i = 0; i < 4; ++i)
1253         {
1254           glVertex3fv (pv[j+i].xyz);
1255         }
1256         glEnd();
1257       }
1258     }
1259   }
1260 }
1261
1262 // =======================================================================
1263 // function : DrawDegeneratesQuadranglesAsLines
1264 // purpose  :
1265 // =======================================================================
1266 void OpenGl_PrimitiveArray::DrawDegeneratesQuadranglestripsAsLines (const float theSkipRatio) const
1267
1268   Tint i, j, k, n, ni;
1269   tel_point pv = myPArray->vertices;
1270
1271   if (myPArray->num_bounds > 0)
1272   {
1273     for (i = n = 0; i < myPArray->num_bounds; ++i)
1274     {
1275       ni = myPArray->bounds[i] / 2 - 2;
1276       k = int((1.0f - theSkipRatio) * ni);
1277       for (; k > 0; --k)
1278       {
1279         j = OGL_Rand() % ni; j = j * 2 + 2;
1280         myPArray->keys[n+j] = -myPArray->keys[n+j];
1281       }
1282       for (j = 3; j < myPArray->bounds[i]; j += 2)
1283       {
1284         if (myPArray->keys[n+j] < 0)
1285         {
1286           myPArray->keys[n+j] = -myPArray->keys[n+j];
1287           glBegin (GL_LINE_LOOP);
1288           glVertex3fv (pv[n+j-3].xyz);
1289           glVertex3fv (pv[n+j-2].xyz);
1290           glVertex3fv (pv[n+j-1].xyz);
1291           glVertex3fv (pv[n+j].xyz);
1292           glEnd();
1293         }
1294       }
1295       n += myPArray->bounds[i];
1296     }
1297   }
1298   else
1299   {
1300     ni = myPArray->num_vertexs / 2 - 2;
1301     k = int((1.0f - theSkipRatio) * ni);
1302     for (; k > 0; --k)
1303     {
1304       j = OGL_Rand() % ni; j = j * 2 + 2;
1305       myPArray->keys[j] = -myPArray->keys[j];
1306     }
1307     for (j = 3; j < myPArray->num_vertexs; j += 2)
1308     {
1309       if (myPArray->keys[j] < 0)
1310       {
1311         myPArray->keys[j] = -myPArray->keys[j];
1312         glBegin (GL_LINE_LOOP);
1313         glVertex3fv (pv[j-3].xyz);
1314         glVertex3fv (pv[j-2].xyz);
1315         glVertex3fv (pv[j-1].xyz);
1316         glVertex3fv (pv[j].xyz);
1317         glEnd();
1318       }
1319     }
1320   }
1321 }
1322
1323 // =======================================================================
1324 // function : DrawDegeneratesAsLines
1325 // purpose  :
1326 // =======================================================================
1327 void OpenGl_PrimitiveArray::DrawDegeneratesAsLines (const TEL_COLOUR*               theEdgeColour,
1328                                                     const Handle(OpenGl_Workspace)& theWorkspace) const
1329 {
1330   const float aSkipRatio = theWorkspace->SkipRatio;
1331
1332   GLboolean zbuff_state = glIsEnabled (GL_DEPTH_TEST);
1333
1334   glDisable (GL_LIGHTING);
1335
1336   if (zbuff_state)
1337     glDisable (GL_DEPTH_TEST); 
1338
1339   glColor3fv (theEdgeColour->rgb);
1340
1341   if (aSkipRatio != 0.0f)
1342   {
1343     switch (myDrawMode)
1344     {
1345       case GL_POINTS:
1346         if (aSkipRatio < 1.0f)
1347           DrawDegeneratesPointsAsPoints();
1348         break;
1349       case GL_LINES:
1350         DrawDegeneratesLinesAsLines (aSkipRatio);
1351         break;
1352       case GL_LINE_STRIP:
1353       case GL_POLYGON:
1354         DrawDegeneratesPolygonsAsLines (aSkipRatio);
1355         break;
1356       case GL_TRIANGLES:
1357         DrawDegeneratesTrianglesAsLines (aSkipRatio);
1358         break;
1359       case GL_QUADS:
1360         DrawDegeneratesQuadranglesAsLines (aSkipRatio);
1361         break;
1362       case GL_TRIANGLE_FAN:
1363       case GL_TRIANGLE_STRIP:
1364         DrawDegeneratesTrianglestripsAsLines (aSkipRatio);
1365         break;
1366       case GL_QUAD_STRIP:
1367         DrawDegeneratesQuadranglestripsAsLines (aSkipRatio);
1368         break;
1369       default:
1370         break;
1371     }
1372   }
1373   else
1374   {
1375     int i,n;
1376     glPushAttrib (GL_POLYGON_BIT);
1377     glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
1378
1379     GLboolean color_array_mode         = glIsEnabled (GL_COLOR_ARRAY);
1380     GLboolean edge_flag_array_mode     = glIsEnabled (GL_EDGE_FLAG_ARRAY);
1381     GLboolean index_array_mode         = glIsEnabled (GL_INDEX_ARRAY);
1382     GLboolean normal_array_mode        = glIsEnabled (GL_NORMAL_ARRAY);
1383     GLboolean texture_coord_array_mode = glIsEnabled (GL_TEXTURE_COORD_ARRAY);
1384     GLboolean vertex_array_mode        = glIsEnabled (GL_VERTEX_ARRAY);
1385
1386     glDisableClientState (GL_COLOR_ARRAY);
1387     glDisableClientState (GL_EDGE_FLAG_ARRAY);
1388     glDisableClientState (GL_INDEX_ARRAY);
1389     glDisableClientState (GL_NORMAL_ARRAY);
1390     glDisableClientState (GL_TEXTURE_COORD_ARRAY);
1391
1392     if (!vertex_array_mode)
1393       glEnableClientState (GL_VERTEX_ARRAY);
1394
1395     glVertexPointer (3, GL_FLOAT, 0, myPArray->vertices); // array of vertices
1396
1397     if (myPArray->num_bounds > 0)
1398     {
1399       if (myPArray->num_edges > 0)
1400       {
1401         for (i = n = 0; i < myPArray->num_bounds; ++i)
1402         {
1403           glDrawElements (myDrawMode, myPArray->bounds[i], GL_UNSIGNED_INT, (GLenum* )&myPArray->edges[n]);
1404           n += myPArray->bounds[i];
1405         }
1406       }
1407       else
1408       {
1409         for (i = n = 0; i < myPArray->num_bounds; ++i)
1410         {
1411           glDrawArrays (myDrawMode, n, myPArray->bounds[i]);
1412           n += myPArray->bounds[i];
1413         }
1414       }
1415     }
1416     else if (myPArray->num_edges > 0)
1417     {
1418       glDrawElements (myDrawMode, myPArray->num_edges, GL_UNSIGNED_INT, (GLenum* )myPArray->edges);
1419     }
1420     else
1421     {
1422       glDrawArrays (myDrawMode, 0, myPArray->num_vertexs);
1423     }
1424
1425     if (!vertex_array_mode) glDisableClientState (GL_VERTEX_ARRAY);
1426
1427     if (color_array_mode)         glEnableClientState (GL_COLOR_ARRAY);
1428     if (edge_flag_array_mode)     glEnableClientState (GL_EDGE_FLAG_ARRAY);
1429     if (index_array_mode)         glEnableClientState (GL_INDEX_ARRAY);
1430     if (normal_array_mode)        glEnableClientState (GL_NORMAL_ARRAY);
1431     if (texture_coord_array_mode) glEnableClientState (GL_TEXTURE_COORD_ARRAY);
1432
1433     glPopAttrib();
1434   }
1435
1436   if (zbuff_state)
1437     glEnable(GL_DEPTH_TEST); 
1438 }  
1439
1440 // =======================================================================
1441 // function : DrawDegeneratesAsBBoxs
1442 // purpose  :
1443 // =======================================================================
1444 void OpenGl_PrimitiveArray::DrawDegeneratesAsBBoxs (const TEL_COLOUR* theEdgeColour) const
1445 {
1446   GLfloat minp[3] = { FLT_MAX, FLT_MAX, FLT_MAX };
1447   GLfloat maxp[3] = { FLT_MIN, FLT_MIN, FLT_MIN };
1448   tel_point pv = myPArray->vertices;
1449
1450   glDisable (GL_LIGHTING);
1451
1452   glColor3fv (theEdgeColour->rgb);
1453
1454   for (Tint i = 0; i < myPArray->num_vertexs; ++i)
1455   {
1456     if (pv[i].xyz[0] < minp[0])
1457       minp[0] = pv[i].xyz[0];
1458     if (pv[i].xyz[1] < minp[1])
1459       minp[1] = pv[i].xyz[1];
1460     if (pv[i].xyz[2] < minp[2])
1461       minp[2] = pv[i].xyz[2];
1462
1463     if (pv[i].xyz[0] > maxp[0])
1464       maxp[0] = pv[i].xyz[0];
1465     if (pv[i].xyz[1] > maxp[1])
1466       maxp[1] = pv[i].xyz[1];
1467     if (pv[i].xyz[2] > maxp[2])
1468       maxp[2] = pv[i].xyz[2];
1469   }
1470
1471   glBegin (GL_LINE_STRIP);
1472
1473   glVertex3fv (minp);
1474   glVertex3f (minp[0], maxp[1], minp[2]);
1475   glVertex3f (minp[0], maxp[1], maxp[2]);
1476   glVertex3f (minp[0], minp[1], maxp[2]);
1477   glVertex3f (minp[0], minp[1], minp[2]);
1478
1479   glVertex3f (maxp[0], minp[1], minp[2]);
1480   glVertex3f (maxp[0], maxp[1], minp[2]);
1481   glVertex3f (maxp[0], maxp[1], maxp[2]);
1482   glVertex3f (maxp[0], minp[1], maxp[2]);
1483   glVertex3f (maxp[0], minp[1], minp[2]);
1484
1485   glVertex3f (maxp[0], minp[1], maxp[2]);
1486   glVertex3f (minp[0], minp[1], maxp[2]);
1487   glVertex3f (minp[0], maxp[1], maxp[2]);
1488   glVertex3fv (maxp);
1489   glVertex3f (maxp[0], maxp[1], minp[2]);
1490   glVertex3f (minp[0], maxp[1], minp[2]);
1491
1492   glEnd();
1493 }
1494
1495 // =======================================================================
1496 // function : OpenGl_PrimitiveArray
1497 // purpose  :
1498 // =======================================================================
1499 OpenGl_PrimitiveArray::OpenGl_PrimitiveArray (CALL_DEF_PARRAY* thePArray)
1500 : myPArray (thePArray),
1501   myDrawMode (DRAW_MODE_NONE),
1502   myIsVboInit (Standard_False)
1503 {
1504   switch (myPArray->type)
1505   {
1506     case TelPointsArrayType:
1507       myDrawMode = GL_POINTS;
1508       break;
1509     case TelPolylinesArrayType:
1510       myDrawMode = GL_LINE_STRIP;
1511       break;
1512     case TelSegmentsArrayType:
1513       myDrawMode = GL_LINES;
1514       break;
1515     case TelPolygonsArrayType:
1516       myDrawMode = GL_POLYGON;
1517       break;
1518     case TelTrianglesArrayType:
1519       myDrawMode = GL_TRIANGLES;
1520       break;
1521     case TelQuadranglesArrayType:
1522       myDrawMode = GL_QUADS;
1523       break;
1524     case TelTriangleStripsArrayType:
1525       myDrawMode = GL_TRIANGLE_STRIP;
1526       break;
1527     case TelQuadrangleStripsArrayType:
1528       myDrawMode = GL_QUAD_STRIP;
1529       break;
1530     case TelTriangleFansArrayType:
1531       myDrawMode = GL_TRIANGLE_FAN;
1532       break;
1533   }
1534 }
1535
1536 // =======================================================================
1537 // function : ~OpenGl_PrimitiveArray
1538 // purpose  :
1539 // =======================================================================
1540 OpenGl_PrimitiveArray::~OpenGl_PrimitiveArray()
1541 {
1542   //
1543 }
1544
1545 // =======================================================================
1546 // function : Release
1547 // purpose  :
1548 // =======================================================================
1549 void OpenGl_PrimitiveArray::Release (const Handle(OpenGl_Context)& theContext)
1550 {
1551   for (Standard_Integer anIter = 0; anIter < VBOMaxType; ++anIter)
1552   {
1553     if (!myVbos[anIter].IsNull())
1554     {
1555       theContext->DelayedRelease (myVbos[anIter]);
1556       myVbos[anIter].Nullify();
1557     }
1558   }
1559 }
1560
1561 // =======================================================================
1562 // function : Render
1563 // purpose  :
1564 // =======================================================================
1565 void OpenGl_PrimitiveArray::Render (const Handle(OpenGl_Workspace)& theWorkspace) const
1566 {
1567   if (myPArray == NULL || myDrawMode == DRAW_MODE_NONE || myPArray->num_vertexs <= 0)
1568     return;
1569
1570   // create VBOs on first render call
1571   if (!myIsVboInit && OpenGl_GraphicDriver::ToUseVBO() && theWorkspace->GetGlContext()->core15 != NULL)
1572   {
1573     BuildVBO (theWorkspace);
1574     myIsVboInit = Standard_True;
1575   }
1576
1577   switch (myPArray->type)
1578   {
1579     case TelPointsArrayType:
1580     case TelPolylinesArrayType:
1581     case TelSegmentsArrayType:
1582     {
1583       glDisable (GL_LIGHTING);
1584
1585       if ((theWorkspace->NamedStatus & OPENGL_NS_ANIMATION) != 0 &&
1586           (theWorkspace->NamedStatus & OPENGL_NS_WIREFRAME) == 0 &&
1587            theWorkspace->DegenerateModel)
1588       {
1589         glDisable (GL_DEPTH_TEST);
1590         if (theWorkspace->NamedStatus & OPENGL_NS_TEXTURE)
1591           DisableTexture();
1592         theWorkspace->NamedStatus |= OPENGL_NS_WIREFRAME;
1593       }
1594       break;
1595     }
1596     case TelPolygonsArrayType:
1597     case TelTrianglesArrayType:
1598     case TelQuadranglesArrayType:
1599     case TelTriangleStripsArrayType:
1600     case TelTriangleFansArrayType:
1601     case TelQuadrangleStripsArrayType:
1602     {
1603       if ((theWorkspace->NamedStatus & OPENGL_NS_ANIMATION) != 0 &&
1604           (theWorkspace->NamedStatus & OPENGL_NS_WIREFRAME) != 0 &&
1605            theWorkspace->DegenerateModel < 2)
1606       {
1607         if (theWorkspace->NamedStatus & OPENGL_NS_TEXTURE)
1608           EnableTexture();
1609         glEnable (GL_DEPTH_TEST);
1610         theWorkspace->NamedStatus &= ~OPENGL_NS_WIREFRAME;
1611       }
1612       break;
1613     }
1614     default:
1615       break;
1616   }
1617
1618   const OpenGl_AspectFace*   anAspectFace   = theWorkspace->AspectFace   (Standard_True);
1619   const OpenGl_AspectLine*   anAspectLine   = theWorkspace->AspectLine   (Standard_True);
1620   const OpenGl_AspectMarker* anAspectMarker = theWorkspace->AspectMarker (myPArray->type == TelPointsArrayType);
1621
1622   Tint aFrontLightingModel = anAspectFace->Context().IntFront.color_mask;
1623   const TEL_COLOUR* anInteriorColor = &anAspectFace->Context().IntFront.matcol;
1624   const TEL_COLOUR* anEdgeColor = &anAspectFace->AspectEdge()->Color();
1625   const TEL_COLOUR* aLineColor = (myPArray->type == TelPointsArrayType) ? &anAspectMarker->Color() : &anAspectLine->Color();
1626
1627   // Use highlight colors
1628   if (theWorkspace->NamedStatus & OPENGL_NS_HIGHLIGHT)
1629   {                         
1630     anEdgeColor = anInteriorColor = aLineColor = theWorkspace->HighlightColor;
1631     aFrontLightingModel = 0;
1632   }
1633
1634   DrawArray (aFrontLightingModel,
1635              anAspectFace->Context().InteriorStyle,
1636              anAspectFace->Context().Edge,
1637              anInteriorColor,
1638              aLineColor,
1639              anEdgeColor,
1640              &anAspectFace->Context().IntFront,
1641              theWorkspace);
1642
1643   switch (myPArray->type)
1644   {
1645     case TelPointsArrayType:
1646     case TelPolylinesArrayType:
1647     case TelSegmentsArrayType:
1648     {
1649       if (theWorkspace->NamedStatus & OPENGL_NS_TEXTURE)
1650         EnableTexture();
1651     }
1652   }
1653 }