0027670: Visualization - avoid duplication of structures defining primitive array...
[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 #include <Graphic3d_TextureParams.hxx>
28 #include <NCollection_AlignedAllocator.hxx>
29
30 namespace
31 {
32   //! Convert data type to GL info
33   inline GLenum toGlDataType (const Graphic3d_TypeOfData theType,
34                               GLint&                     theNbComp)
35   {
36     switch (theType)
37     {
38       case Graphic3d_TOD_USHORT:
39         theNbComp = 1;
40         return GL_UNSIGNED_SHORT;
41       case Graphic3d_TOD_UINT:
42         theNbComp = 1;
43         return GL_UNSIGNED_INT;
44       case Graphic3d_TOD_VEC2:
45         theNbComp = 2;
46         return GL_FLOAT;
47       case Graphic3d_TOD_VEC3:
48         theNbComp = 3;
49         return GL_FLOAT;
50       case Graphic3d_TOD_VEC4:
51         theNbComp = 4;
52         return GL_FLOAT;
53       case Graphic3d_TOD_VEC4UB:
54         theNbComp = 4;
55         return GL_UNSIGNED_BYTE;
56       case Graphic3d_TOD_FLOAT:
57         theNbComp = 1;
58         return GL_FLOAT;
59     }
60     theNbComp = 0;
61     return GL_NONE;
62   }
63
64 }
65
66 //! Auxiliary template for VBO with interleaved attributes.
67 template<class TheBaseClass, int NbAttributes>
68 class OpenGl_VertexBufferT : public TheBaseClass
69 {
70
71 public:
72
73   //! Create uninitialized VBO.
74   OpenGl_VertexBufferT (const Graphic3d_Attribute* theAttribs,
75                         const Standard_Integer     theStride)
76   : Stride (theStride)
77   {
78     memcpy (Attribs, theAttribs, sizeof(Graphic3d_Attribute) * NbAttributes);
79   }
80
81   //! Create uninitialized VBO.
82   OpenGl_VertexBufferT (const Graphic3d_Buffer& theAttribs)
83   : Stride (theAttribs.Stride)
84   {
85     memcpy (Attribs, theAttribs.AttributesArray(), sizeof(Graphic3d_Attribute) * NbAttributes);
86   }
87
88   virtual bool HasColorAttribute() const
89   {
90     for (Standard_Integer anAttribIter = 0; anAttribIter < NbAttributes; ++anAttribIter)
91     {
92       const Graphic3d_Attribute& anAttrib = Attribs[anAttribIter];
93       if (anAttrib.Id == Graphic3d_TOA_COLOR)
94       {
95         return true;
96       }
97     }
98     return false;
99   }
100
101   virtual bool HasNormalAttribute() const
102   {
103     for (Standard_Integer anAttribIter = 0; anAttribIter < NbAttributes; ++anAttribIter)
104     {
105       const Graphic3d_Attribute& anAttrib = Attribs[anAttribIter];
106       if (anAttrib.Id == Graphic3d_TOA_NORM)
107       {
108         return true;
109       }
110     }
111     return false;
112   }
113
114   virtual void BindPositionAttribute (const Handle(OpenGl_Context)& theGlCtx) const
115   {
116     if (!TheBaseClass::IsValid())
117     {
118       return;
119     }
120
121     TheBaseClass::Bind (theGlCtx);
122     GLint aNbComp;
123     const GLubyte* anOffset = TheBaseClass::myOffset;
124     for (Standard_Integer anAttribIter = 0; anAttribIter < NbAttributes; ++anAttribIter)
125     {
126       const Graphic3d_Attribute& anAttrib = Attribs[anAttribIter];
127       const GLenum   aDataType = toGlDataType (anAttrib.DataType, aNbComp);
128       if (aDataType == GL_NONE)
129       {
130         continue;
131       }
132       else if (anAttrib.Id == Graphic3d_TOA_POS)
133       {
134         TheBaseClass::bindAttribute (theGlCtx, Graphic3d_TOA_POS, aNbComp, aDataType, Stride, anOffset);
135         break;
136       }
137
138       anOffset += Graphic3d_Attribute::Stride (anAttrib.DataType);
139     }
140   }
141
142   virtual void BindAllAttributes (const Handle(OpenGl_Context)& theGlCtx) const
143   {
144     if (!TheBaseClass::IsValid())
145     {
146       return;
147     }
148
149     TheBaseClass::Bind (theGlCtx);
150     GLint aNbComp;
151     const GLubyte* anOffset = TheBaseClass::myOffset;
152     for (Standard_Integer anAttribIter = 0; anAttribIter < NbAttributes; ++anAttribIter)
153     {
154       const Graphic3d_Attribute& anAttrib = Attribs[anAttribIter];
155       const GLenum   aDataType = toGlDataType (anAttrib.DataType, aNbComp);
156       if (aDataType == GL_NONE)
157       {
158         continue;
159       }
160
161       TheBaseClass::bindAttribute (theGlCtx, anAttrib.Id, aNbComp, aDataType, Stride, anOffset);
162       anOffset += Graphic3d_Attribute::Stride (anAttrib.DataType);
163     }
164   }
165
166   virtual void UnbindAllAttributes (const Handle(OpenGl_Context)& theGlCtx) const
167   {
168     if (!TheBaseClass::IsValid())
169     {
170       return;
171     }
172     TheBaseClass::Unbind (theGlCtx);
173
174     for (Standard_Integer anAttribIter = 0; anAttribIter < NbAttributes; ++anAttribIter)
175     {
176       const Graphic3d_Attribute& anAttrib = Attribs[anAttribIter];
177       TheBaseClass::unbindAttribute (theGlCtx, anAttrib.Id);
178     }
179   }
180
181 public:
182
183   Graphic3d_Attribute Attribs[NbAttributes];
184   Standard_Integer    Stride;
185
186 };
187
188 // =======================================================================
189 // function : clearMemoryGL
190 // purpose  :
191 // =======================================================================
192 void OpenGl_PrimitiveArray::clearMemoryGL (const Handle(OpenGl_Context)& theGlCtx) const
193 {
194   if (!myVboIndices.IsNull())
195   {
196     myVboIndices->Release (theGlCtx.operator->());
197     myVboIndices.Nullify();
198   }
199   if (!myVboAttribs.IsNull())
200   {
201     myVboAttribs->Release (theGlCtx.operator->());
202     myVboAttribs.Nullify();
203   }
204 }
205
206 // =======================================================================
207 // function : initNormalVbo
208 // purpose  :
209 // =======================================================================
210 Standard_Boolean OpenGl_PrimitiveArray::initNormalVbo (const Handle(OpenGl_Context)& theCtx) const
211 {
212   switch (myAttribs->NbAttributes)
213   {
214     case 1:  myVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBuffer, 1> (*myAttribs); break;
215     case 2:  myVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBuffer, 2> (*myAttribs); break;
216     case 3:  myVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBuffer, 3> (*myAttribs); break;
217     case 4:  myVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBuffer, 4> (*myAttribs); break;
218     case 5:  myVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBuffer, 5> (*myAttribs); break;
219     case 6:  myVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBuffer, 6> (*myAttribs); break;
220     case 7:  myVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBuffer, 7> (*myAttribs); break;
221     case 8:  myVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBuffer, 8> (*myAttribs); break;
222     case 9:  myVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBuffer, 9> (*myAttribs); break;
223     case 10: myVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBuffer, 10>(*myAttribs); break;
224   }
225
226   if (!myVboAttribs->init (theCtx, 0, myAttribs->NbElements, myAttribs->Data(), GL_NONE, myAttribs->Stride))
227   {
228     TCollection_ExtendedString aMsg;
229     aMsg += "VBO creation for Primitive Array has failed for ";
230     aMsg += myAttribs->NbElements;
231     aMsg += " vertices. Out of memory?";
232     theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PERFORMANCE, 0, GL_DEBUG_SEVERITY_LOW, aMsg);
233
234     clearMemoryGL (theCtx);
235     return Standard_False;
236   }
237   else if (myIndices.IsNull())
238   {
239     return Standard_True;
240   }
241
242   myVboIndices = new OpenGl_IndexBuffer();
243   bool isOk = false;
244   switch (myIndices->Stride)
245   {
246     case 2:
247     {
248       isOk = myVboIndices->Init (theCtx, 1, myIndices->NbElements, reinterpret_cast<const GLushort*> (myIndices->Data()));
249       break;
250     }
251     case 4:
252     {
253       isOk = myVboIndices->Init (theCtx, 1, myIndices->NbElements, reinterpret_cast<const GLuint*> (myIndices->Data()));
254       break;
255     }
256     default:
257     {
258       clearMemoryGL (theCtx);
259       return Standard_False;
260     }
261   }
262   if (!isOk)
263   {
264     TCollection_ExtendedString aMsg;
265     aMsg += "VBO creation for Primitive Array has failed for ";
266     aMsg += myIndices->NbElements;
267     aMsg += " indices. Out of memory?";
268     theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PERFORMANCE, 0, GL_DEBUG_SEVERITY_LOW, aMsg);
269     clearMemoryGL (theCtx);
270     return Standard_False;
271   }
272   return Standard_True;
273 }
274
275 // =======================================================================
276 // function : buildVBO
277 // purpose  :
278 // =======================================================================
279 Standard_Boolean OpenGl_PrimitiveArray::buildVBO (const Handle(OpenGl_Context)& theCtx,
280                                                   const Standard_Boolean        theToKeepData) const
281 {
282   bool isNormalMode = theCtx->ToUseVbo();
283   clearMemoryGL (theCtx);
284   if (myAttribs.IsNull()
285    || myAttribs->IsEmpty()
286    || myAttribs->NbElements < 1
287    || myAttribs->NbAttributes < 1
288    || myAttribs->NbAttributes > 10)
289   {
290     // vertices should be always defined - others are optional
291     return Standard_False;
292   }
293
294   if (isNormalMode
295    && initNormalVbo (theCtx))
296   {
297     if (!theCtx->caps->keepArrayData
298      && !theToKeepData)
299     {
300       myIndices.Nullify();
301       myAttribs.Nullify();
302     }
303     return Standard_True;
304   }
305
306   Handle(OpenGl_VertexBufferCompat) aVboAttribs;
307   switch (myAttribs->NbAttributes)
308   {
309     case 1:  aVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBufferCompat, 1> (*myAttribs); break;
310     case 2:  aVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBufferCompat, 2> (*myAttribs); break;
311     case 3:  aVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBufferCompat, 3> (*myAttribs); break;
312     case 4:  aVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBufferCompat, 4> (*myAttribs); break;
313     case 5:  aVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBufferCompat, 5> (*myAttribs); break;
314     case 6:  aVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBufferCompat, 6> (*myAttribs); break;
315     case 7:  aVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBufferCompat, 7> (*myAttribs); break;
316     case 8:  aVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBufferCompat, 8> (*myAttribs); break;
317     case 9:  aVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBufferCompat, 9> (*myAttribs); break;
318     case 10: aVboAttribs = new OpenGl_VertexBufferT<OpenGl_VertexBufferCompat, 10>(*myAttribs); break;
319   }
320   aVboAttribs->initLink (myAttribs, 0, myAttribs->NbElements, GL_NONE);
321   if (!myIndices.IsNull())
322   {
323     Handle(OpenGl_VertexBufferCompat) aVboIndices = new OpenGl_VertexBufferCompat();
324     switch (myIndices->Stride)
325     {
326       case 2:
327       {
328         aVboIndices->initLink (myIndices, 1, myIndices->NbElements, GL_UNSIGNED_SHORT);
329         break;
330       }
331       case 4:
332       {
333         aVboIndices->initLink (myIndices, 1, myIndices->NbElements, GL_UNSIGNED_INT);
334         break;
335       }
336       default:
337       {
338         return Standard_False;
339       }
340     }
341     myVboIndices = aVboIndices;
342   }
343   myVboAttribs = aVboAttribs;
344   if (!theCtx->caps->keepArrayData
345    && !theToKeepData)
346   {
347     // does not make sense for compatibility mode
348     //myIndices.Nullify();
349     //myAttribs.Nullify();
350   }
351
352   return Standard_True;
353 }
354
355 // =======================================================================
356 // function : drawArray
357 // purpose  :
358 // =======================================================================
359 void OpenGl_PrimitiveArray::drawArray (const Handle(OpenGl_Workspace)& theWorkspace,
360                                        const Graphic3d_Vec4*           theFaceColors,
361                                        const Standard_Boolean          theHasVertColor) const
362 {
363   const Handle(OpenGl_Context)& aGlContext  = theWorkspace->GetGlContext();
364   const bool                    toHilight   = theWorkspace->ToHighlight();
365   bool                          hasVColors  = theHasVertColor && !toHilight;
366   if (myVboAttribs.IsNull())
367   {
368   #if !defined(GL_ES_VERSION_2_0)
369     if (myDrawMode == GL_POINTS)
370     {
371       // extreme compatibility mode - without sprites but with markers
372       drawMarkers (theWorkspace);
373     }
374   #endif
375     return;
376   }
377
378   myVboAttribs->BindAllAttributes (aGlContext);
379   if (theHasVertColor && toHilight)
380   {
381     // disable per-vertex color
382     OpenGl_VertexBuffer::unbindAttribute (aGlContext, Graphic3d_TOA_COLOR);
383   }
384   if (!myVboIndices.IsNull())
385   {
386     myVboIndices->Bind (aGlContext);
387     GLubyte* anOffset = myVboIndices->GetDataOffset();
388     if (!myBounds.IsNull())
389     {
390       // draw primitives by vertex count with the indices
391       const size_t aStride = myVboIndices->GetDataType() == GL_UNSIGNED_SHORT ? sizeof(unsigned short) : sizeof(unsigned int);
392       for (Standard_Integer aGroupIter = 0; aGroupIter < myBounds->NbBounds; ++aGroupIter)
393       {
394         const GLint aNbElemsInGroup = myBounds->Bounds[aGroupIter];
395         if (theFaceColors != NULL) aGlContext->SetColor4fv (theFaceColors[aGroupIter]);
396         glDrawElements (myDrawMode, aNbElemsInGroup, myVboIndices->GetDataType(), anOffset);
397         anOffset += aStride * aNbElemsInGroup;
398       }
399     }
400     else
401     {
402       // draw one (or sequential) primitive by the indices
403       glDrawElements (myDrawMode, myVboIndices->GetElemsNb(), myVboIndices->GetDataType(), anOffset);
404     }
405     myVboIndices->Unbind (aGlContext);
406   }
407   else if (!myBounds.IsNull())
408   {
409     GLint aFirstElem = 0;
410     for (Standard_Integer aGroupIter = 0; aGroupIter < myBounds->NbBounds; ++aGroupIter)
411     {
412       const GLint aNbElemsInGroup = myBounds->Bounds[aGroupIter];
413       if (theFaceColors != NULL) aGlContext->SetColor4fv (theFaceColors[aGroupIter]);
414       glDrawArrays (myDrawMode, aFirstElem, aNbElemsInGroup);
415       aFirstElem += aNbElemsInGroup;
416     }
417   }
418   else
419   {
420     if (myDrawMode == GL_POINTS)
421     {
422       drawMarkers (theWorkspace);
423     }
424     else
425     {
426       glDrawArrays (myDrawMode, 0, myVboAttribs->GetElemsNb());
427     }
428   }
429
430   // bind with 0
431   myVboAttribs->UnbindAllAttributes (aGlContext);
432
433   if (hasVColors)
434   {
435     theWorkspace->NamedStatus |= OPENGL_NS_RESMAT;
436   }
437 }
438
439 // =======================================================================
440 // function : drawEdges
441 // purpose  :
442 // =======================================================================
443 void OpenGl_PrimitiveArray::drawEdges (const OpenGl_Vec4&              theEdgeColour,
444                                        const Handle(OpenGl_Workspace)& theWorkspace) const
445 {
446   const Handle(OpenGl_Context)& aGlContext = theWorkspace->GetGlContext();
447   if (myVboAttribs.IsNull())
448   {
449     return;
450   }
451
452 #if !defined(GL_ES_VERSION_2_0)
453   if (aGlContext->core11 != NULL)
454   {
455     glDisable (GL_LIGHTING);
456   }
457 #endif
458
459   const OpenGl_AspectLine* anAspectLineOld = theWorkspace->SetAspectLine (theWorkspace->AspectFace()->AspectEdge());
460   const OpenGl_AspectLine* anAspect = theWorkspace->ApplyAspectLine();
461
462 #if !defined(GL_ES_VERSION_2_0)
463   glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
464 #endif
465
466   if (aGlContext->core20fwd != NULL)
467   {
468     aGlContext->ShaderManager()->BindLineProgram (NULL,
469                                                   anAspect->Aspect()->Type() != Aspect_TOL_SOLID,
470                                                   Standard_False,
471                                                   Standard_False,
472                                                   anAspect->ShaderProgramRes (aGlContext));
473   }
474
475   /// OCC22236 NOTE: draw edges for all situations:
476   /// 1) draw elements with GL_LINE style as edges from myPArray->bufferVBO[VBOEdges] indices array
477   /// 2) draw elements from vertex array, when bounds defines count of primitive's vertices.
478   /// 3) draw primitive's edges by vertexes if no edges and bounds array is specified
479   myVboAttribs->BindPositionAttribute (aGlContext);
480
481   aGlContext->SetColor4fv   (theEdgeColour);
482   aGlContext->SetTypeOfLine (anAspect->Aspect()->Type());
483   aGlContext->SetLineWidth  (anAspect->Aspect()->Width());
484
485   if (!myVboIndices.IsNull())
486   {
487     myVboIndices->Bind (aGlContext);
488     GLubyte* anOffset = myVboIndices->GetDataOffset();
489
490     // draw primitives by vertex count with the indices
491     if (!myBounds.IsNull())
492     {
493       const size_t aStride = myVboIndices->GetDataType() == GL_UNSIGNED_SHORT ? sizeof(unsigned short) : sizeof(unsigned int);
494       for (Standard_Integer aGroupIter = 0; aGroupIter < myBounds->NbBounds; ++aGroupIter)
495       {
496         const GLint aNbElemsInGroup = myBounds->Bounds[aGroupIter];
497         glDrawElements (myDrawMode, aNbElemsInGroup, myVboIndices->GetDataType(), anOffset);
498         anOffset += aStride * aNbElemsInGroup;
499       }
500     }
501     // draw one (or sequential) primitive by the indices
502     else
503     {
504       glDrawElements (myDrawMode, myVboIndices->GetElemsNb(), myVboIndices->GetDataType(), anOffset);
505     }
506     myVboIndices->Unbind (aGlContext);
507   }
508   else if (!myBounds.IsNull())
509   {
510     GLint aFirstElem = 0;
511     for (Standard_Integer aGroupIter = 0; aGroupIter < myBounds->NbBounds; ++aGroupIter)
512     {
513       const GLint aNbElemsInGroup = myBounds->Bounds[aGroupIter];
514       glDrawArrays (myDrawMode, aFirstElem, aNbElemsInGroup);
515       aFirstElem += aNbElemsInGroup;
516     }
517   }
518   else
519   {
520     glDrawArrays (myDrawMode, 0, !myVboAttribs.IsNull() ? myVboAttribs->GetElemsNb() : myAttribs->NbElements);
521   }
522
523   // unbind buffers
524   myVboAttribs->UnbindAttribute (aGlContext, Graphic3d_TOA_POS);
525
526   // restore line context
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->ApplyAspectMarker();
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     aCtx->SetPointSpriteOrigin();
545   #if !defined(GL_ES_VERSION_2_0)
546     if (aCtx->core11 != NULL)
547     {
548       aCtx->core11fwd->glEnable (GL_ALPHA_TEST);
549       aCtx->core11fwd->glAlphaFunc (GL_GEQUAL, 0.1f);
550     }
551   #endif
552
553     aCtx->core11fwd->glEnable (GL_BLEND);
554     aCtx->core11fwd->glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
555
556     aCtx->core11fwd->glDrawArrays (myDrawMode, 0, !myVboAttribs.IsNull() ? myVboAttribs->GetElemsNb() : myAttribs->NbElements);
557
558     aCtx->core11fwd->glDisable (GL_BLEND);
559   #if !defined(GL_ES_VERSION_2_0)
560     if (aCtx->core11 != NULL)
561     {
562       aCtx->core11fwd->glDisable (GL_ALPHA_TEST);
563     }
564   #endif
565     aCtx->SetPointSize (1.0f);
566     return;
567   }
568   else if (anAspectMarker->Aspect()->Type() == Aspect_TOM_POINT)
569   {
570     aCtx->SetPointSize (anAspectMarker->MarkerSize());
571     aCtx->core11fwd->glDrawArrays (myDrawMode, 0, !myVboAttribs.IsNull() ? myVboAttribs->GetElemsNb() : myAttribs->NbElements);
572     aCtx->SetPointSize (1.0f);
573   }
574 #if !defined(GL_ES_VERSION_2_0)
575   // Textured markers will be drawn with the glBitmap
576   else if (anAspectMarker->Aspect()->Type() != Aspect_TOM_POINT
577        && !aSpriteNorm.IsNull())
578   {
579     /**if (!isHilight && (myPArray->vcolours != NULL))
580     {
581       for (Standard_Integer anIter = 0; anIter < myAttribs->NbElements; anIter++)
582       {
583         glColor4ubv    (myPArray->vcolours[anIter].GetData());
584         glRasterPos3fv (myAttribs->Value<Graphic3d_Vec3> (anIter).GetData());
585         aSpriteNorm->DrawBitmap (theWorkspace->GetGlContext());
586       }
587     }
588     else*/
589     {
590       for (Standard_Integer anIter = 0; anIter < myAttribs->NbElements; anIter++)
591       {
592         aCtx->core11->glRasterPos3fv (myAttribs->Value<Graphic3d_Vec3> (anIter).GetData());
593         aSpriteNorm->DrawBitmap (theWorkspace->GetGlContext());
594       }
595     }
596   }
597 #endif
598 }
599
600 // =======================================================================
601 // function : OpenGl_PrimitiveArray
602 // purpose  :
603 // =======================================================================
604 OpenGl_PrimitiveArray::OpenGl_PrimitiveArray (const OpenGl_GraphicDriver* theDriver)
605
606 : myDrawMode  (DRAW_MODE_NONE),
607   myIsVboInit (Standard_False)
608 {
609   if (theDriver != NULL)
610   {
611     myUID = theDriver->GetNextPrimitiveArrayUID();
612   }
613 }
614
615 // =======================================================================
616 // function : OpenGl_PrimitiveArray
617 // purpose  :
618 // =======================================================================
619 OpenGl_PrimitiveArray::OpenGl_PrimitiveArray (const OpenGl_GraphicDriver*          theDriver,
620                                               const Graphic3d_TypeOfPrimitiveArray theType,
621                                               const Handle(Graphic3d_IndexBuffer)& theIndices,
622                                               const Handle(Graphic3d_Buffer)&      theAttribs,
623                                               const Handle(Graphic3d_BoundBuffer)& theBounds)
624
625 : myIndices   (theIndices),
626   myAttribs   (theAttribs),
627   myBounds    (theBounds),
628   myDrawMode  (DRAW_MODE_NONE),
629   myIsVboInit (Standard_False)
630 {
631   if (!myIndices.IsNull()
632     && myIndices->NbElements < 1)
633   {
634     // dummy index buffer?
635     myIndices.Nullify();
636   }
637
638   if (theDriver != NULL)
639   {
640     myUID = theDriver->GetNextPrimitiveArrayUID();
641   #if defined (GL_ES_VERSION_2_0)
642     const Handle(OpenGl_Context)& aCtx = theDriver->GetSharedContext();
643     if (!aCtx.IsNull())
644     {
645       processIndices (aCtx);
646     }
647   #endif
648   }
649
650   setDrawMode (theType);
651 }
652
653 // =======================================================================
654 // function : ~OpenGl_PrimitiveArray
655 // purpose  :
656 // =======================================================================
657 OpenGl_PrimitiveArray::~OpenGl_PrimitiveArray()
658 {
659   //
660 }
661
662 // =======================================================================
663 // function : Release
664 // purpose  :
665 // =======================================================================
666 void OpenGl_PrimitiveArray::Release (OpenGl_Context* theContext)
667 {
668   myIsVboInit = Standard_False;
669   if (!myVboIndices.IsNull())
670   {
671     if (theContext)
672     {
673       theContext->DelayedRelease (myVboIndices);
674     }
675     myVboIndices.Nullify();
676   }
677   if (!myVboAttribs.IsNull())
678   {
679     if (theContext)
680     {
681       theContext->DelayedRelease (myVboAttribs);
682     }
683     myVboAttribs.Nullify();
684   }
685 }
686
687 // =======================================================================
688 // function : Render
689 // purpose  :
690 // =======================================================================
691 void OpenGl_PrimitiveArray::Render (const Handle(OpenGl_Workspace)& theWorkspace) const
692 {
693   if (myDrawMode == DRAW_MODE_NONE)
694   {
695     return;
696   }
697
698   const OpenGl_AspectFace*   anAspectFace   = theWorkspace->ApplyAspectFace();
699   const OpenGl_AspectLine*   anAspectLine   = theWorkspace->ApplyAspectLine();
700   const OpenGl_AspectMarker* anAspectMarker = myDrawMode == GL_POINTS
701                                             ? theWorkspace->ApplyAspectMarker()
702                                             : theWorkspace->AspectMarker();
703
704   // create VBOs on first render call
705   const Handle(OpenGl_Context)& aCtx = theWorkspace->GetGlContext();
706   if (!myIsVboInit)
707   {
708     // compatibility - keep data to draw markers using display lists
709     const Standard_Boolean toKeepData = myDrawMode == GL_POINTS
710                                     && !anAspectMarker->SpriteRes (aCtx).IsNull()
711                                     &&  anAspectMarker->SpriteRes (aCtx)->IsDisplayList();
712   #if defined (GL_ES_VERSION_2_0)
713     processIndices (aCtx);
714   #endif
715     buildVBO (aCtx, toKeepData);
716     myIsVboInit = Standard_True;
717   }
718
719   const Standard_Boolean hasColorAttrib = !myVboAttribs.IsNull()
720                                         && myVboAttribs->HasColorAttribute();
721   const Standard_Boolean isLightOn = !anAspectFace->IsNoLighting()
722                                   && !myVboAttribs.IsNull()
723                                   &&  myVboAttribs->HasNormalAttribute();
724 #if !defined(GL_ES_VERSION_2_0)
725   // manage FFP lighting
726   if (aCtx->core11 != NULL)
727   {
728     if (!isLightOn)
729     {
730       glDisable (GL_LIGHTING);
731     }
732     else
733     {
734       glEnable (GL_LIGHTING);
735     }
736   }
737 #endif
738   // Temporarily disable environment mapping
739   Handle(OpenGl_Texture) aTextureBack;
740   if (myDrawMode <= GL_LINE_STRIP)
741   {
742     aTextureBack = theWorkspace->DisableTexture();
743   }
744
745   if ((myDrawMode >  GL_LINE_STRIP && anAspectFace->Aspect()->InteriorStyle() != Aspect_IS_EMPTY) ||
746       (myDrawMode <= GL_LINE_STRIP))
747   {
748     const bool             toHilight    = theWorkspace->ToHighlight();
749     const Standard_Boolean hasVertColor = hasColorAttrib && !toHilight;
750     if (aCtx->core20fwd != NULL)
751     {
752       switch (myDrawMode)
753       {
754         case GL_POINTS:
755         {
756           const Handle(OpenGl_PointSprite)& aSpriteNorm = anAspectMarker->SpriteRes (aCtx);
757           if (!aSpriteNorm.IsNull()
758            && !aSpriteNorm->IsDisplayList())
759           {
760             const Handle(OpenGl_PointSprite)& aSprite = (toHilight && anAspectMarker->SpriteHighlightRes (aCtx)->IsValid())
761                                                       ? anAspectMarker->SpriteHighlightRes (aCtx)
762                                                       : aSpriteNorm;
763             theWorkspace->EnableTexture (aSprite);
764             aCtx->ShaderManager()->BindMarkerProgram (aSprite, isLightOn, hasVertColor, anAspectMarker->ShaderProgramRes (aCtx));
765           }
766           else
767           {
768             aCtx->ShaderManager()->BindMarkerProgram (NULL, isLightOn, hasVertColor, anAspectMarker->ShaderProgramRes (aCtx));
769           }
770           break;
771         }
772         case GL_LINES:
773         case GL_LINE_STRIP:
774         {
775           aCtx->ShaderManager()->BindLineProgram (NULL,
776                                                   anAspectLine->Aspect()->Type() != Aspect_TOL_SOLID,
777                                                   isLightOn,
778                                                   hasVertColor,
779                                                   anAspectLine->ShaderProgramRes (aCtx));
780           break;
781         }
782         default:
783         {
784           const Handle(OpenGl_Texture)& aTexture = theWorkspace->ActiveTexture();
785           const Standard_Boolean isLightOnFace = isLightOn
786                                               && (aTexture.IsNull()
787                                                || aTexture->GetParams()->IsModulate());
788           const Standard_Boolean toEnableEnvMap = (!aTexture.IsNull() && (aTexture == theWorkspace->EnvironmentTexture()));
789           aCtx->ShaderManager()->BindFaceProgram (aTexture,
790                                                   isLightOnFace,
791                                                   hasVertColor,
792                                                   toEnableEnvMap,
793                                                   anAspectFace->ShaderProgramRes (aCtx));
794           break;
795         }
796       }
797     }
798
799     // All primitives should gather material properties from the AspectFace in shading mode
800     if (isLightOn)
801     {
802       aCtx->SetShadingMaterial (anAspectFace, theWorkspace->ToHighlight() ? theWorkspace->HighlightColor : NULL);
803     }
804
805     if (!theWorkspace->ActiveTexture().IsNull()
806      && myDrawMode != GL_POINTS) // transformation is not supported within point sprites
807     {
808       aCtx->SetTextureMatrix (theWorkspace->ActiveTexture()->GetParams());
809     }
810
811     if (myDrawMode <= GL_LINE_STRIP)
812     {
813       const OpenGl_Vec4& aLineColor = myDrawMode == GL_POINTS ? theWorkspace->MarkerColor() : theWorkspace->LineColor();
814       aCtx->SetColor4fv (aLineColor);
815     }
816     else
817     {
818       const OpenGl_Vec4& anInteriorColor = theWorkspace->InteriorColor();
819       aCtx->SetColor4fv (anInteriorColor);
820     }
821     if (myDrawMode == GL_LINES
822      || myDrawMode == GL_LINE_STRIP)
823     {
824       aCtx->SetTypeOfLine (anAspectLine->Aspect()->Type());
825       aCtx->SetLineWidth  (anAspectLine->Aspect()->Width());
826     }
827
828     const Graphic3d_Vec4* aFaceColors = !myBounds.IsNull() && !toHilight && anAspectFace->Aspect()->InteriorStyle() != Aspect_IS_HIDDENLINE
829                                       ?  myBounds->Colors
830                                       :  NULL;
831     drawArray (theWorkspace, aFaceColors, hasColorAttrib);
832   }
833
834   if (myDrawMode <= GL_LINE_STRIP)
835   {
836     theWorkspace->EnableTexture (aTextureBack);
837   }
838   else
839   {
840     if (anAspectFace->Aspect()->ToDrawEdges()
841      || anAspectFace->Aspect()->InteriorStyle() == Aspect_IS_HIDDENLINE)
842     {
843       const OpenGl_Vec4& anEdgeColor = theWorkspace->EdgeColor();
844       drawEdges (anEdgeColor, theWorkspace);
845
846       // restore OpenGL polygon mode if needed
847     #if !defined(GL_ES_VERSION_2_0)
848       if (anAspectFace->Aspect()->InteriorStyle() >= Aspect_IS_HATCH)
849       {
850         glPolygonMode (GL_FRONT_AND_BACK,
851           anAspectFace->Aspect()->InteriorStyle() == Aspect_IS_POINT ? GL_POINT : GL_FILL);
852       }
853     #endif
854     }
855   }
856
857   aCtx->BindProgram (NULL);
858 }
859
860 // =======================================================================
861 // function : setDrawMode
862 // purpose  :
863 // =======================================================================
864 void OpenGl_PrimitiveArray::setDrawMode (const Graphic3d_TypeOfPrimitiveArray theType)
865 {
866   if (myAttribs.IsNull())
867   {
868     myDrawMode = DRAW_MODE_NONE;
869     return;
870   }
871
872   switch (theType)
873   {
874     case Graphic3d_TOPA_POINTS:
875       myDrawMode = GL_POINTS;
876       break;
877     case Graphic3d_TOPA_POLYLINES:
878       myDrawMode = GL_LINE_STRIP;
879       break;
880     case Graphic3d_TOPA_SEGMENTS:
881       myDrawMode = GL_LINES;
882       break;
883     case Graphic3d_TOPA_TRIANGLES:
884       myDrawMode = GL_TRIANGLES;
885       break;
886     case Graphic3d_TOPA_TRIANGLESTRIPS:
887       myDrawMode = GL_TRIANGLE_STRIP;
888       break;
889     case Graphic3d_TOPA_TRIANGLEFANS:
890       myDrawMode = GL_TRIANGLE_FAN;
891       break;
892   #if !defined(GL_ES_VERSION_2_0)
893     case Graphic3d_TOPA_POLYGONS:
894       myDrawMode = GL_POLYGON;
895       break;
896     case Graphic3d_TOPA_QUADRANGLES:
897       myDrawMode = GL_QUADS;
898       break;
899     case Graphic3d_TOPA_QUADRANGLESTRIPS:
900       myDrawMode = GL_QUAD_STRIP;
901       break;
902   #else
903     case Graphic3d_TOPA_POLYGONS:
904     case Graphic3d_TOPA_QUADRANGLES:
905     case Graphic3d_TOPA_QUADRANGLESTRIPS:
906   #endif
907     case Graphic3d_TOPA_UNDEFINED:
908       break;
909   }
910 }
911
912 // =======================================================================
913 // function : processIndices
914 // purpose  :
915 // =======================================================================
916 Standard_Boolean OpenGl_PrimitiveArray::processIndices (const Handle(OpenGl_Context)& theContext) const
917 {
918   if (myIndices.IsNull()
919    || theContext->hasUintIndex)
920   {
921     return Standard_True;
922   }
923
924   if (myIndices->NbElements > std::numeric_limits<GLushort>::max())
925   {
926     Handle(Graphic3d_Buffer) anAttribs = new Graphic3d_Buffer (new NCollection_AlignedAllocator (16));
927     if (!anAttribs->Init (myIndices->NbElements, myAttribs->AttributesArray(), myAttribs->NbAttributes))
928     {
929       return Standard_False; // failed to initialize attribute array
930     }
931
932     for (Standard_Integer anIdxIdx = 0; anIdxIdx < myIndices->NbElements; ++anIdxIdx)
933     {
934       const Standard_Integer anIndex = myIndices->Index (anIdxIdx);
935       memcpy (anAttribs->ChangeData() + myAttribs->Stride * anIdxIdx,
936               myAttribs->Data()       + myAttribs->Stride * anIndex,
937               myAttribs->Stride);
938     }
939
940     myIndices.Nullify();
941     myAttribs = anAttribs;
942   }
943
944   return Standard_True;
945 }
946
947 // =======================================================================
948 // function : InitBuffers
949 // purpose  :
950 // =======================================================================
951 void OpenGl_PrimitiveArray::InitBuffers (const Handle(OpenGl_Context)&        theContext,
952                                          const Graphic3d_TypeOfPrimitiveArray theType,
953                                          const Handle(Graphic3d_IndexBuffer)& theIndices,
954                                          const Handle(Graphic3d_Buffer)&      theAttribs,
955                                          const Handle(Graphic3d_BoundBuffer)& theBounds)
956 {
957   // Release old graphic resources
958   Release (theContext.operator->());
959
960   myIndices = theIndices;
961   myAttribs = theAttribs;
962   myBounds = theBounds;
963 #if defined(GL_ES_VERSION_2_0)
964   processIndices (theContext);
965 #endif
966
967   setDrawMode (theType);
968 }