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