0025442: Visualization, TKOpenGl - prevent inclusion of system header glxext.h
[occt.git] / src / OpenGl / OpenGl_PrimitiveArray.cxx
1 // Created on: 2011-07-13
2 // Created by: Sergey ZERCHANINOV
3 // Copyright (c) 2011-2013 OPEN CASCADE SAS
4 //
5 // This file is part of Open CASCADE Technology software library.
6 //
7 // This library is free software; you can redistribute it and/or modify it under
8 // the terms of the GNU Lesser General Public License version 2.1 as published
9 // by the Free Software Foundation, with special exception defined in the file
10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 // distribution for complete text of the license and disclaimer of any warranty.
12 //
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement.
15
16 #include <OpenGl_AspectFace.hxx>
17 #include <OpenGl_Context.hxx>
18 #include <OpenGl_GraphicDriver.hxx>
19 #include <OpenGl_IndexBuffer.hxx>
20 #include <OpenGl_PointSprite.hxx>
21 #include <OpenGl_PrimitiveArray.hxx>
22 #include <OpenGl_ShaderManager.hxx>
23 #include <OpenGl_ShaderProgram.hxx>
24 #include <OpenGl_Structure.hxx>
25 #include <OpenGl_VertexBufferCompat.hxx>
26 #include <OpenGl_Workspace.hxx>
27
28 namespace
29 {
30   //! Convert index data type from size
31   inline GLenum toGlIndexType (const Standard_Integer theStride)
32   {
33     switch (theStride)
34     {
35       case 2:  return GL_UNSIGNED_SHORT;
36       case 4:  return GL_UNSIGNED_INT;
37       default: return GL_NONE;
38     }
39   }
40
41   //! Convert data type to GL info
42   inline GLenum toGlDataType (const Graphic3d_TypeOfData theType,
43                               GLint&                     theNbComp)
44   {
45     switch (theType)
46     {
47       case Graphic3d_TOD_USHORT:
48         theNbComp = 1;
49         return GL_UNSIGNED_SHORT;
50       case Graphic3d_TOD_UINT:
51         theNbComp = 1;
52         return GL_UNSIGNED_INT;
53       case Graphic3d_TOD_VEC2:
54         theNbComp = 2;
55         return GL_FLOAT;
56       case Graphic3d_TOD_VEC3:
57         theNbComp = 3;
58         return GL_FLOAT;
59       case Graphic3d_TOD_VEC4:
60         theNbComp = 4;
61         return GL_FLOAT;
62       case Graphic3d_TOD_VEC4UB:
63         theNbComp = 4;
64         return GL_UNSIGNED_BYTE;
65     }
66     theNbComp = 0;
67     return GL_NONE;
68   }
69
70 }
71
72 //! Auxiliary template for VBO with interleaved attributes.
73 template<class TheBaseClass, int NbAttributes>
74 class OpenGl_VertexBufferT : public TheBaseClass
75 {
76
77 public:
78
79   //! Create uninitialized VBO.
80   OpenGl_VertexBufferT (const Graphic3d_Attribute* theAttribs,
81                         const Standard_Integer     theStride)
82   : Stride (theStride)
83   {
84     memcpy (Attribs, theAttribs, sizeof(Graphic3d_Attribute) * NbAttributes);
85   }
86
87   //! Create uninitialized VBO.
88   OpenGl_VertexBufferT (const Graphic3d_Buffer& theAttribs)
89   : Stride (theAttribs.Stride)
90   {
91     memcpy (Attribs, theAttribs.AttributesArray(), sizeof(Graphic3d_Attribute) * NbAttributes);
92   }
93
94   virtual bool HasColorAttribute() const
95   {
96     for (Standard_Integer anAttribIter = 0; anAttribIter < NbAttributes; ++anAttribIter)
97     {
98       const Graphic3d_Attribute& anAttrib = Attribs[anAttribIter];
99       if (anAttrib.Id == Graphic3d_TOA_COLOR)
100       {
101         return true;
102       }
103     }
104     return false;
105   }
106
107   virtual bool HasNormalAttribute() const
108   {
109     for (Standard_Integer anAttribIter = 0; anAttribIter < NbAttributes; ++anAttribIter)
110     {
111       const Graphic3d_Attribute& anAttrib = Attribs[anAttribIter];
112       if (anAttrib.Id == Graphic3d_TOA_NORM)
113       {
114         return true;
115       }
116     }
117     return false;
118   }
119
120   virtual void BindPositionAttribute (const Handle(OpenGl_Context)& theGlCtx) const
121   {
122     if (!TheBaseClass::IsValid())
123     {
124       return;
125     }
126
127     TheBaseClass::Bind (theGlCtx);
128     GLint aNbComp;
129     const GLubyte* anOffset = TheBaseClass::myOffset;
130     for (Standard_Integer anAttribIter = 0; anAttribIter < NbAttributes; ++anAttribIter)
131     {
132       const Graphic3d_Attribute& anAttrib = Attribs[anAttribIter];
133       const GLenum   aDataType = toGlDataType (anAttrib.DataType, aNbComp);
134       if (aDataType == GL_NONE)
135       {
136         continue;
137       }
138       else if (anAttrib.Id == Graphic3d_TOA_POS)
139       {
140         TheBaseClass::bindAttribute (theGlCtx, Graphic3d_TOA_POS, aNbComp, aDataType, Stride, anOffset);
141         break;
142       }
143
144       anOffset += Graphic3d_Attribute::Stride (anAttrib.DataType);
145     }
146   }
147
148   virtual void BindAllAttributes (const Handle(OpenGl_Context)& theGlCtx) const
149   {
150     if (!TheBaseClass::IsValid())
151     {
152       return;
153     }
154
155     TheBaseClass::Bind (theGlCtx);
156     GLint aNbComp;
157     const GLubyte* anOffset = TheBaseClass::myOffset;
158     for (Standard_Integer anAttribIter = 0; anAttribIter < NbAttributes; ++anAttribIter)
159     {
160       const Graphic3d_Attribute& anAttrib = Attribs[anAttribIter];
161       const GLenum   aDataType = toGlDataType (anAttrib.DataType, aNbComp);
162       if (aDataType == GL_NONE)
163       {
164         continue;
165       }
166
167       TheBaseClass::bindAttribute (theGlCtx, anAttrib.Id, aNbComp, aDataType, Stride, anOffset);
168       anOffset += Graphic3d_Attribute::Stride (anAttrib.DataType);
169     }
170   }
171
172   virtual void UnbindAllAttributes (const Handle(OpenGl_Context)& theGlCtx) const
173   {
174     if (!TheBaseClass::IsValid())
175     {
176       return;
177     }
178     TheBaseClass::Unbind (theGlCtx);
179
180     for (Standard_Integer anAttribIter = 0; anAttribIter < NbAttributes; ++anAttribIter)
181     {
182       const Graphic3d_Attribute& anAttrib = Attribs[anAttribIter];
183       TheBaseClass::unbindAttribute (theGlCtx, anAttrib.Id);
184     }
185   }
186
187 public:
188
189   Graphic3d_Attribute Attribs[NbAttributes];
190   Standard_Integer    Stride;
191
192 };
193
194 // =======================================================================
195 // function : clearMemoryGL
196 // purpose  :
197 // =======================================================================
198 void OpenGl_PrimitiveArray::clearMemoryGL (const Handle(OpenGl_Context)& theGlCtx) const
199 {
200   if (!myVboIndices.IsNull())
201   {
202     myVboIndices->Release (theGlCtx.operator->());
203     myVboIndices.Nullify();
204   }
205   if (!myVboAttribs.IsNull())
206   {
207     myVboAttribs->Release (theGlCtx.operator->());
208     myVboAttribs.Nullify();
209   }
210 }
211
212 // =======================================================================
213 // function : initNormalVbo
214 // purpose  :
215 // =======================================================================
216 Standard_Boolean OpenGl_PrimitiveArray::initNormalVbo (const Handle(OpenGl_Context)& theCtx) const
217 {
218   switch (myAttribs->NbAttributes)
219   {
220     case 1:  myVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBuffer, 1> (*myAttribs); break;
221     case 2:  myVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBuffer, 2> (*myAttribs); break;
222     case 3:  myVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBuffer, 3> (*myAttribs); break;
223     case 4:  myVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBuffer, 4> (*myAttribs); break;
224     case 5:  myVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBuffer, 5> (*myAttribs); break;
225     case 6:  myVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBuffer, 6> (*myAttribs); break;
226     case 7:  myVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBuffer, 7> (*myAttribs); break;
227     case 8:  myVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBuffer, 8> (*myAttribs); break;
228     case 9:  myVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBuffer, 9> (*myAttribs); break;
229     case 10: myVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBuffer, 10>(*myAttribs); break;
230   }
231
232   if (!myVboAttribs->init (theCtx, 0, myAttribs->NbElements, myAttribs->Data(), GL_NONE, myAttribs->Stride))
233   {
234     TCollection_ExtendedString aMsg;
235     aMsg += "VBO creation for Primitive Array has failed for ";
236     aMsg += myAttribs->NbElements;
237     aMsg += " vertices. Out of memory?";
238     theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB, GL_DEBUG_TYPE_PERFORMANCE_ARB, 0, GL_DEBUG_SEVERITY_LOW_ARB, aMsg);
239
240     clearMemoryGL (theCtx);
241     return Standard_False;
242   }
243   else if (myIndices.IsNull())
244   {
245     return Standard_True;
246   }
247
248   myVboIndices = new OpenGl_IndexBuffer();
249   bool isOk = false;
250   switch (myIndices->Stride)
251   {
252     case 2:
253     {
254       isOk = myVboIndices->Init (theCtx, 1, myIndices->NbElements, reinterpret_cast<const GLushort*> (myIndices->Data()));
255       break;
256     }
257     case 4:
258     {
259       isOk = myVboIndices->Init (theCtx, 1, myIndices->NbElements, reinterpret_cast<const GLuint*> (myIndices->Data()));
260       break;
261     }
262     default:
263     {
264       clearMemoryGL (theCtx);
265       return Standard_False;
266     }
267   }
268   if (!isOk)
269   {
270     TCollection_ExtendedString aMsg;
271     aMsg += "VBO creation for Primitive Array has failed for ";
272     aMsg += myIndices->NbElements;
273     aMsg += " indices. Out of memory?";
274     theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB, GL_DEBUG_TYPE_PERFORMANCE_ARB, 0, GL_DEBUG_SEVERITY_LOW_ARB, aMsg);
275     clearMemoryGL (theCtx);
276     return Standard_False;
277   }
278   return Standard_True;
279 }
280
281 // =======================================================================
282 // function : buildVBO
283 // purpose  :
284 // =======================================================================
285 Standard_Boolean OpenGl_PrimitiveArray::buildVBO (const Handle(OpenGl_Context)& theCtx,
286                                                   const Standard_Boolean        theToKeepData) const
287 {
288   bool isNormalMode = theCtx->ToUseVbo();
289   if (myAttribs.IsNull()
290    || myAttribs->IsEmpty()
291    || myAttribs->NbElements < 1
292    || myAttribs->NbAttributes < 1
293    || myAttribs->NbAttributes > 10)
294   {
295     // vertices should be always defined - others are optional
296     return Standard_False;
297   }
298
299   if (isNormalMode
300    && initNormalVbo (theCtx))
301   {
302     if (!theCtx->caps->keepArrayData
303      && !theToKeepData)
304     {
305       myIndices.Nullify();
306       myAttribs.Nullify();
307     }
308     return Standard_True;
309   }
310
311   Handle(OpenGl_VertexBufferCompat) aVboAttribs;
312   switch (myAttribs->NbAttributes)
313   {
314     case 1:  aVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBufferCompat, 1> (*myAttribs); break;
315     case 2:  aVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBufferCompat, 2> (*myAttribs); break;
316     case 3:  aVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBufferCompat, 3> (*myAttribs); break;
317     case 4:  aVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBufferCompat, 4> (*myAttribs); break;
318     case 5:  aVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBufferCompat, 5> (*myAttribs); break;
319     case 6:  aVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBufferCompat, 6> (*myAttribs); break;
320     case 7:  aVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBufferCompat, 7> (*myAttribs); break;
321     case 8:  aVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBufferCompat, 8> (*myAttribs); break;
322     case 9:  aVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBufferCompat, 9> (*myAttribs); break;
323     case 10: aVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBufferCompat, 10>(*myAttribs); break;
324   }
325   aVboAttribs->initLink (myAttribs, 0, myAttribs->NbElements, GL_NONE);
326   if (!myIndices.IsNull())
327   {
328     Handle(OpenGl_VertexBufferCompat) aVboIndices = new OpenGl_VertexBufferCompat();
329     switch (myIndices->Stride)
330     {
331       case 2:
332       {
333         aVboIndices->initLink (myIndices, 1, myIndices->NbElements, GL_UNSIGNED_SHORT);
334         break;
335       }
336       case 4:
337       {
338         aVboIndices->initLink (myIndices, 1, myIndices->NbElements, GL_UNSIGNED_INT);
339         break;
340       }
341       default:
342       {
343         return Standard_False;
344       }
345     }
346     myVboIndices = aVboIndices;
347   }
348   myVboAttribs = aVboAttribs;
349   if (!theCtx->caps->keepArrayData
350    && !theToKeepData)
351   {
352     // does not make sense for compatibility mode
353     //myIndices.Nullify();
354     //myAttribs.Nullify();
355   }
356
357   return Standard_True;
358 }
359
360 // =======================================================================
361 // function : drawArray
362 // purpose  :
363 // =======================================================================
364 void OpenGl_PrimitiveArray::drawArray (const Handle(OpenGl_Workspace)& theWorkspace,
365                                        const Graphic3d_Vec4*           theFaceColors,
366                                        const Standard_Boolean          theHasVertColor) const
367 {
368   const Handle(OpenGl_Context)& aGlContext  = theWorkspace->GetGlContext();
369   const bool                    toHilight   = (theWorkspace->NamedStatus & OPENGL_NS_HIGHLIGHT) != 0;
370   bool                          hasVColors  = theHasVertColor && !toHilight;
371   if (myVboAttribs.IsNull())
372   {
373   #if !defined(GL_ES_VERSION_2_0)
374     if (myDrawMode == GL_POINTS)
375     {
376       // extreme compatibility mode - without sprites but with markers
377       drawMarkers (theWorkspace);
378     }
379   #endif
380     return;
381   }
382
383   myVboAttribs->BindAllAttributes (aGlContext);
384   if (theHasVertColor && toHilight)
385   {
386     // disable per-vertex color
387     OpenGl_VertexBuffer::unbindAttribute (aGlContext, Graphic3d_TOA_COLOR);
388   }
389   if (!myVboIndices.IsNull())
390   {
391     myVboIndices->Bind (aGlContext);
392     GLubyte* anOffset = myVboIndices->GetDataOffset();
393     if (!myBounds.IsNull())
394     {
395       // draw primitives by vertex count with the indices
396       const size_t aStride = myVboIndices->GetDataType() == GL_UNSIGNED_SHORT ? sizeof(unsigned short) : sizeof(unsigned int);
397       for (Standard_Integer aGroupIter = 0; aGroupIter < myBounds->NbBounds; ++aGroupIter)
398       {
399         const GLint aNbElemsInGroup = myBounds->Bounds[aGroupIter];
400         if (theFaceColors != NULL) aGlContext->SetColor4fv (theFaceColors[aGroupIter]);
401         glDrawElements (myDrawMode, aNbElemsInGroup, myVboIndices->GetDataType(), anOffset);
402         anOffset += aStride * aNbElemsInGroup;
403       }
404     }
405     else
406     {
407       // draw one (or sequential) primitive by the indices
408       glDrawElements (myDrawMode, myVboIndices->GetElemsNb(), myVboIndices->GetDataType(), anOffset);
409     }
410     myVboIndices->Unbind (aGlContext);
411   }
412   else if (!myBounds.IsNull())
413   {
414     GLint aFirstElem = 0;
415     for (Standard_Integer aGroupIter = 0; aGroupIter < myBounds->NbBounds; ++aGroupIter)
416     {
417       const GLint aNbElemsInGroup = myBounds->Bounds[aGroupIter];
418       if (theFaceColors != NULL) aGlContext->SetColor4fv (theFaceColors[aGroupIter]);
419       glDrawArrays (myDrawMode, aFirstElem, aNbElemsInGroup);
420       aFirstElem += aNbElemsInGroup;
421     }
422   }
423   else
424   {
425     if (myDrawMode == GL_POINTS)
426     {
427       drawMarkers (theWorkspace);
428     }
429     else
430     {
431       glDrawArrays (myDrawMode, 0, myVboAttribs->GetElemsNb());
432     }
433   }
434
435   // bind with 0
436   myVboAttribs->UnbindAllAttributes (aGlContext);
437
438   if (hasVColors)
439   {
440     theWorkspace->NamedStatus |= OPENGL_NS_RESMAT;
441   }
442 }
443
444 // =======================================================================
445 // function : drawEdges
446 // purpose  :
447 // =======================================================================
448 void OpenGl_PrimitiveArray::drawEdges (const TEL_COLOUR*               theEdgeColour,
449                                        const Handle(OpenGl_Workspace)& theWorkspace) const
450 {
451   if (myVboAttribs.IsNull())
452   {
453     return;
454   }
455
456 #if !defined(GL_ES_VERSION_2_0)
457   glDisable (GL_LIGHTING);
458 #endif
459
460   const Handle(OpenGl_Context)& aGlContext = theWorkspace->GetGlContext();
461   const OpenGl_AspectLine* anAspectLineOld = NULL;
462
463   anAspectLineOld = theWorkspace->SetAspectLine (theWorkspace->AspectFace (Standard_True)->AspectEdge());
464   const OpenGl_AspectLine* anAspect = theWorkspace->AspectLine (Standard_True);
465
466 #if !defined(GL_ES_VERSION_2_0)
467   glPushAttrib (GL_POLYGON_BIT);
468   glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
469 #endif
470
471   if (aGlContext->IsGlGreaterEqual (2, 0))
472   {
473     aGlContext->ShaderManager()->BindProgram (anAspect, NULL, Standard_False, Standard_False, anAspect->ShaderProgramRes (aGlContext));
474   }
475
476   /// OCC22236 NOTE: draw edges for all situations:
477   /// 1) draw elements with GL_LINE style as edges from myPArray->bufferVBO[VBOEdges] indices array
478   /// 2) draw elements from vertex array, when bounds defines count of primitive's vertices.
479   /// 3) draw primitive's edges by vertexes if no edges and bounds array is specified
480   myVboAttribs->BindPositionAttribute (aGlContext);
481   aGlContext->SetColor4fv (*(const OpenGl_Vec4* )theEdgeColour->rgb);
482   if (!myVboIndices.IsNull())
483   {
484     myVboIndices->Bind (aGlContext);
485     GLubyte* anOffset = myVboIndices->GetDataOffset();
486
487     // draw primitives by vertex count with the indices
488     if (!myBounds.IsNull())
489     {
490       const size_t aStride = myVboIndices->GetDataType() == GL_UNSIGNED_SHORT ? sizeof(unsigned short) : sizeof(unsigned int);
491       for (Standard_Integer aGroupIter = 0; aGroupIter < myBounds->NbBounds; ++aGroupIter)
492       {
493         const GLint aNbElemsInGroup = myBounds->Bounds[aGroupIter];
494         glDrawElements (myDrawMode, aNbElemsInGroup, myVboIndices->GetDataType(), anOffset);
495         anOffset += aStride * aNbElemsInGroup;
496       }
497     }
498     // draw one (or sequential) primitive by the indices
499     else
500     {
501       glDrawElements (myDrawMode, myVboIndices->GetElemsNb(), myVboIndices->GetDataType(), anOffset);
502     }
503     myVboIndices->Unbind (aGlContext);
504   }
505   else if (!myBounds.IsNull())
506   {
507     GLint aFirstElem = 0;
508     for (Standard_Integer aGroupIter = 0; aGroupIter < myBounds->NbBounds; ++aGroupIter)
509     {
510       const GLint aNbElemsInGroup = myBounds->Bounds[aGroupIter];
511       glDrawArrays (myDrawMode, aFirstElem, aNbElemsInGroup);
512       aFirstElem += aNbElemsInGroup;
513     }
514   }
515   else
516   {
517     glDrawArrays (myDrawMode, 0, myAttribs->NbElements);
518   }
519
520   // unbind buffers
521   myVboAttribs->UnbindAttribute (aGlContext, Graphic3d_TOA_POS);
522
523   // restore line context
524 #if !defined(GL_ES_VERSION_2_0)
525   glPopAttrib();
526 #endif
527   theWorkspace->SetAspectLine (anAspectLineOld);
528 }
529
530 // =======================================================================
531 // function : drawMarkers
532 // purpose  :
533 // =======================================================================
534 void OpenGl_PrimitiveArray::drawMarkers (const Handle(OpenGl_Workspace)& theWorkspace) const
535 {
536   const OpenGl_AspectMarker* anAspectMarker     = theWorkspace->AspectMarker (Standard_True);
537   const Handle(OpenGl_Context)&     aCtx        = theWorkspace->GetGlContext();
538   const Handle(OpenGl_PointSprite)& aSpriteNorm = anAspectMarker->SpriteRes (aCtx);
539   if (!aSpriteNorm.IsNull()
540    && !aSpriteNorm->IsDisplayList())
541   {
542     // Textured markers will be drawn with the point sprites
543     aCtx->SetPointSize (anAspectMarker->MarkerSize());
544   #if !defined(GL_ES_VERSION_2_0)
545     aCtx->core11fwd->glEnable (GL_ALPHA_TEST);
546     aCtx->core11fwd->glAlphaFunc (GL_GEQUAL, 0.1f);
547   #endif
548
549     aCtx->core11fwd->glEnable (GL_BLEND);
550     aCtx->core11fwd->glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
551
552     aCtx->core11fwd->glDrawArrays (myDrawMode, 0, !myVboAttribs.IsNull() ? myVboAttribs->GetElemsNb() : myAttribs->NbElements);
553
554     aCtx->core11fwd->glDisable (GL_BLEND);
555   #if !defined(GL_ES_VERSION_2_0)
556     aCtx->core11fwd->glDisable (GL_ALPHA_TEST);
557   #endif
558     aCtx->SetPointSize (1.0f);
559     return;
560   }
561   else if (anAspectMarker->Type() == Aspect_TOM_POINT)
562   {
563     aCtx->SetPointSize (anAspectMarker->MarkerSize());
564     aCtx->core11fwd->glDrawArrays (myDrawMode, 0, !myVboAttribs.IsNull() ? myVboAttribs->GetElemsNb() : myAttribs->NbElements);
565     aCtx->SetPointSize (1.0f);
566   }
567 #if !defined(GL_ES_VERSION_2_0)
568   // Textured markers will be drawn with the glBitmap
569   else if (anAspectMarker->Type() != Aspect_TOM_POINT
570        && !aSpriteNorm.IsNull())
571   {
572     /**if (!isHilight && (myPArray->vcolours != NULL))
573     {
574       for (Standard_Integer anIter = 0; anIter < myAttribs->NbElements; anIter++)
575       {
576         glColor4ubv    (myPArray->vcolours[anIter].GetData());
577         glRasterPos3fv (myAttribs->Value<Graphic3d_Vec3> (anIter).GetData());
578         aSpriteNorm->DrawBitmap (theWorkspace->GetGlContext());
579       }
580     }
581     else*/
582     {
583       for (Standard_Integer anIter = 0; anIter < myAttribs->NbElements; anIter++)
584       {
585         aCtx->core11->glRasterPos3fv (myAttribs->Value<Graphic3d_Vec3> (anIter).GetData());
586         aSpriteNorm->DrawBitmap (theWorkspace->GetGlContext());
587       }
588     }
589   }
590 #endif
591 }
592
593 // =======================================================================
594 // function : OpenGl_PrimitiveArray
595 // purpose  :
596 // =======================================================================
597 OpenGl_PrimitiveArray::OpenGl_PrimitiveArray (const OpenGl_GraphicDriver*          theDriver,
598                                               const Graphic3d_TypeOfPrimitiveArray theType,
599                                               const Handle(Graphic3d_IndexBuffer)& theIndices,
600                                               const Handle(Graphic3d_Buffer)&      theAttribs,
601                                               const Handle(Graphic3d_BoundBuffer)& theBounds)
602
603 : myIndices   (theIndices),
604   myAttribs   (theAttribs),
605   myBounds    (theBounds),
606   myDrawMode  (DRAW_MODE_NONE),
607   myIsVboInit (Standard_False),
608   myUID       (theDriver->GetNextPrimitiveArrayUID())
609 {
610   if (!myIndices.IsNull()
611     && myIndices->NbElements < 1)
612   {
613     // dummy index buffer?
614     myIndices.Nullify();
615   }
616   if (myAttribs.IsNull())
617   {
618     return;
619   }
620
621   switch (theType)
622   {
623     case Graphic3d_TOPA_POINTS:
624       myDrawMode = GL_POINTS;
625       break;
626     case Graphic3d_TOPA_POLYLINES:
627       myDrawMode = GL_LINE_STRIP;
628       break;
629     case Graphic3d_TOPA_SEGMENTS:
630       myDrawMode = GL_LINES;
631       break;
632     case Graphic3d_TOPA_TRIANGLES:
633       myDrawMode = GL_TRIANGLES;
634       break;
635     case Graphic3d_TOPA_TRIANGLESTRIPS:
636       myDrawMode = GL_TRIANGLE_STRIP;
637       break;
638     case Graphic3d_TOPA_TRIANGLEFANS:
639       myDrawMode = GL_TRIANGLE_FAN;
640       break;
641   #if !defined(GL_ES_VERSION_2_0)
642     case Graphic3d_TOPA_POLYGONS:
643       myDrawMode = GL_POLYGON;
644       break;
645     case Graphic3d_TOPA_QUADRANGLES:
646       myDrawMode = GL_QUADS;
647       break;
648     case Graphic3d_TOPA_QUADRANGLESTRIPS:
649       myDrawMode = GL_QUAD_STRIP;
650       break;
651   #else
652     case Graphic3d_TOPA_POLYGONS:
653     case Graphic3d_TOPA_QUADRANGLES:
654     case Graphic3d_TOPA_QUADRANGLESTRIPS:
655   #endif
656     case Graphic3d_TOPA_UNDEFINED:
657       break;
658   }
659 }
660
661 // =======================================================================
662 // function : ~OpenGl_PrimitiveArray
663 // purpose  :
664 // =======================================================================
665 OpenGl_PrimitiveArray::~OpenGl_PrimitiveArray()
666 {
667   //
668 }
669
670 // =======================================================================
671 // function : Release
672 // purpose  :
673 // =======================================================================
674 void OpenGl_PrimitiveArray::Release (OpenGl_Context* theContext)
675 {
676   if (!myVboIndices.IsNull())
677   {
678     if (theContext)
679     {
680       theContext->DelayedRelease (myVboIndices);
681     }
682     myVboIndices.Nullify();
683   }
684   if (!myVboAttribs.IsNull())
685   {
686     if (theContext)
687     {
688       theContext->DelayedRelease (myVboAttribs);
689     }
690     myVboAttribs.Nullify();
691   }
692 }
693
694 // =======================================================================
695 // function : Render
696 // purpose  :
697 // =======================================================================
698 void OpenGl_PrimitiveArray::Render (const Handle(OpenGl_Workspace)& theWorkspace) const
699 {
700   if (myDrawMode == DRAW_MODE_NONE)
701   {
702     return;
703   }
704
705   const OpenGl_AspectFace*   anAspectFace   = theWorkspace->AspectFace   (Standard_True);
706   const OpenGl_AspectLine*   anAspectLine   = theWorkspace->AspectLine   (Standard_True);
707   const OpenGl_AspectMarker* anAspectMarker = theWorkspace->AspectMarker (myDrawMode == GL_POINTS);
708
709   // create VBOs on first render call
710   const Handle(OpenGl_Context)& aCtx = theWorkspace->GetGlContext();
711   if (!myIsVboInit)
712   {
713     // compatibility - keep data to draw markers using display lists
714     const Standard_Boolean toKeepData = myDrawMode == GL_POINTS
715                                     && !anAspectMarker->SpriteRes (aCtx).IsNull()
716                                     &&  anAspectMarker->SpriteRes (aCtx)->IsDisplayList();
717     buildVBO (aCtx, toKeepData);
718     myIsVboInit = Standard_True;
719   }
720
721   Tint aFrontLightingModel = anAspectFace->IntFront().color_mask;
722   const TEL_COLOUR* anInteriorColor = &anAspectFace->IntFront().matcol;
723   const TEL_COLOUR* anEdgeColor = &anAspectFace->AspectEdge()->Color();
724   const TEL_COLOUR* aLineColor  = myDrawMode == GL_POINTS ? &anAspectMarker->Color() : &anAspectLine->Color();
725
726   // Use highlight colors
727   if (theWorkspace->NamedStatus & OPENGL_NS_HIGHLIGHT)
728   {
729     anEdgeColor = anInteriorColor = aLineColor = theWorkspace->HighlightColor;
730     aFrontLightingModel = 0;
731   }
732
733   const Standard_Boolean hasColorAttrib = !myVboAttribs.IsNull()
734                                         && myVboAttribs->HasColorAttribute();
735   const Standard_Boolean isLightOn = aFrontLightingModel != 0
736                                  && !myVboAttribs.IsNull()
737                                  &&  myVboAttribs->HasNormalAttribute();
738 #if !defined(GL_ES_VERSION_2_0)
739   // manage FFP lighting
740   if (!isLightOn)
741   {
742     glDisable (GL_LIGHTING);
743   }
744   else
745   {
746     glEnable (GL_LIGHTING);
747   }
748 #endif
749   // Temporarily disable environment mapping
750   Handle(OpenGl_Texture) aTextureBack;
751   if (myDrawMode <= GL_LINE_STRIP)
752   {
753     aTextureBack = theWorkspace->DisableTexture();
754   }
755
756   if ((myDrawMode >  GL_LINE_STRIP && anAspectFace->InteriorStyle() != Aspect_IS_EMPTY) ||
757       (myDrawMode <= GL_LINE_STRIP))
758   {
759     const bool            toHilight   = (theWorkspace->NamedStatus & OPENGL_NS_HIGHLIGHT) != 0;
760     const Graphic3d_Vec4* aFaceColors = !myBounds.IsNull() && !toHilight && anAspectFace->InteriorStyle() != Aspect_IS_HIDDENLINE
761                                       ?  myBounds->Colors
762                                       :  NULL;
763     const Standard_Boolean hasVertColor = hasColorAttrib && !toHilight;
764     if (aCtx->IsGlGreaterEqual (2, 0))
765     {
766       switch (myDrawMode)
767       {
768         case GL_POINTS:
769         {
770           const Handle(OpenGl_PointSprite)& aSpriteNorm = anAspectMarker->SpriteRes (aCtx);
771           if (!aSpriteNorm.IsNull()
772            && !aSpriteNorm->IsDisplayList())
773           {
774             const Handle(OpenGl_PointSprite)& aSprite = (toHilight && anAspectMarker->SpriteHighlightRes (aCtx)->IsValid())
775                                                       ? anAspectMarker->SpriteHighlightRes (aCtx)
776                                                       : aSpriteNorm;
777             theWorkspace->EnableTexture (aSprite);
778             aCtx->ShaderManager()->BindProgram (anAspectMarker, aSprite, isLightOn, hasVertColor, anAspectMarker->ShaderProgramRes (aCtx));
779           }
780           else
781           {
782             aCtx->ShaderManager()->BindProgram (anAspectMarker, NULL, isLightOn, hasVertColor, anAspectMarker->ShaderProgramRes (aCtx));
783           }
784           break;
785         }
786         case GL_LINES:
787         case GL_LINE_STRIP:
788         {
789           aCtx->ShaderManager()->BindProgram (anAspectLine, NULL, isLightOn, hasVertColor, anAspectLine->ShaderProgramRes (aCtx));
790           break;
791         }
792         default:
793         {
794           aCtx->ShaderManager()->BindProgram (anAspectFace, theWorkspace->ActiveTexture(), isLightOn, hasVertColor, anAspectFace->ShaderProgramRes (aCtx));
795           break;
796         }
797       }
798     }
799
800     aCtx->SetColor4fv (*(const OpenGl_Vec4* )(myDrawMode <= GL_LINE_STRIP ? aLineColor->rgb : anInteriorColor->rgb));
801
802     drawArray (theWorkspace, aFaceColors, hasColorAttrib);
803   }
804
805   if (myDrawMode <= GL_LINE_STRIP)
806   {
807     theWorkspace->EnableTexture (aTextureBack);
808   }
809   else
810   {
811     if (anAspectFace->Edge()
812      || anAspectFace->InteriorStyle() == Aspect_IS_HIDDENLINE)
813     {
814       drawEdges (anEdgeColor, theWorkspace);
815     }
816   }
817
818   aCtx->BindProgram (NULL);
819 }