0030748: Visualization - Marker displayed in immediate layer ruins QT Quick view...
[occt.git] / src / OpenGl / OpenGl_VertexBuffer.hxx
1 // Created by: Kirill GAVRILOV
2 // Copyright (c) 2013-2014 OPEN CASCADE SAS
3 //
4 // This file is part of Open CASCADE Technology software library.
5 //
6 // This library is free software; you can redistribute it and/or modify it under
7 // the terms of the GNU Lesser General Public License version 2.1 as published
8 // by the Free Software Foundation, with special exception defined in the file
9 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
10 // distribution for complete text of the license and disclaimer of any warranty.
11 //
12 // Alternatively, this file may be used under the terms of Open CASCADE
13 // commercial license or contractual agreement.
14
15 #ifndef _OpenGl_VertexBuffer_H__
16 #define _OpenGl_VertexBuffer_H__
17
18 #include <OpenGl_GlCore20.hxx>
19 #include <OpenGl_Resource.hxx>
20 #include <OpenGl_Context.hxx>
21 #include <OpenGl_ShaderProgram.hxx>
22
23 #include <Graphic3d_IndexBuffer.hxx>
24
25 //! Vertex Buffer Object - is a general storage object for vertex attributes (position, normal, color).
26 //! Notice that you should use OpenGl_IndexBuffer specialization for array of indices.
27 class OpenGl_VertexBuffer : public OpenGl_Resource
28 {
29
30 public:
31
32   //! Helpful constants
33   static const GLuint NO_BUFFER = 0;
34
35 public:
36
37   //! Create uninitialized VBO.
38   Standard_EXPORT OpenGl_VertexBuffer();
39
40   //! Destroy object.
41   Standard_EXPORT virtual ~OpenGl_VertexBuffer();
42
43   Standard_EXPORT virtual GLenum GetTarget() const;
44
45   //! Return TRUE if this is a virtual (for backward compatibility) VBO object.
46   virtual bool IsVirtual() const { return false; }
47
48   //! @return true if current object was initialized
49   inline bool IsValid() const
50   {
51     return myBufferId != NO_BUFFER;
52   }
53
54   //! @return the number of components per generic vertex attribute.
55   inline GLuint GetComponentsNb() const
56   {
57     return myComponentsNb;
58   }
59
60   //! @return number of vertex attributes / number of vertices specified within ::Init()
61   inline GLsizei GetElemsNb() const
62   {
63     return myElemsNb;
64   }
65
66   //! Overrides the number of vertex attributes / number of vertexes.
67   //! It is up to user specifying this number correct (e.g. below initial value)!
68   void SetElemsNb (GLsizei theNbElems) { myElemsNb = theNbElems; }
69
70   //! @return data type of each component in the array.
71   inline GLenum GetDataType() const
72   {
73     return myDataType;
74   }
75
76   //! @return offset to data, NULL by default
77   inline GLubyte* GetDataOffset() const
78   {
79     return myOffset;
80   }
81
82   //! Creates VBO name (id) if not yet generated.
83   //! Data should be initialized by another method.
84   Standard_EXPORT virtual bool Create (const Handle(OpenGl_Context)& theGlCtx);
85
86   //! Destroy object - will release GPU memory if any.
87   Standard_EXPORT virtual void Release (OpenGl_Context* theGlCtx) Standard_OVERRIDE;
88
89   //! Bind this VBO.
90   Standard_EXPORT virtual void Bind (const Handle(OpenGl_Context)& theGlCtx) const;
91
92   //! Unbind this VBO.
93   Standard_EXPORT virtual void Unbind (const Handle(OpenGl_Context)& theGlCtx) const;
94
95   //! Notice that VBO will be unbound after this call.
96   //! @param theComponentsNb - specifies the number of components per generic vertex attribute; must be 1, 2, 3, or 4;
97   //! @param theElemsNb      - elements count;
98   //! @param theData         - pointer to GLfloat data (vertices/normals etc.).
99   bool Init (const Handle(OpenGl_Context)& theGlCtx,
100              const GLuint   theComponentsNb,
101              const GLsizei  theElemsNb,
102              const GLfloat* theData)
103   {
104     return init (theGlCtx, theComponentsNb, theElemsNb, theData, GL_FLOAT);
105   }
106
107   //! Notice that VBO will be unbound after this call.
108   //! @param theComponentsNb - specifies the number of components per generic vertex attribute; must be 1, 2, 3, or 4;
109   //! @param theElemsNb      - elements count;
110   //! @param theData         - pointer to GLuint data (indices etc.).
111   bool Init (const Handle(OpenGl_Context)& theGlCtx,
112              const GLuint  theComponentsNb,
113              const GLsizei theElemsNb,
114              const GLuint* theData)
115   {
116     return init (theGlCtx, theComponentsNb, theElemsNb, theData, GL_UNSIGNED_INT);
117   }
118
119   //! Notice that VBO will be unbound after this call.
120   //! @param theComponentsNb - specifies the number of components per generic vertex attribute; must be 1, 2, 3, or 4;
121   //! @param theElemsNb      - elements count;
122   //! @param theData         - pointer to GLushort data (indices etc.).
123   bool Init (const Handle(OpenGl_Context)& theGlCtx,
124              const GLuint    theComponentsNb,
125              const GLsizei   theElemsNb,
126              const GLushort* theData)
127   {
128     return init (theGlCtx, theComponentsNb, theElemsNb, theData, GL_UNSIGNED_SHORT);
129   }
130
131   //! Notice that VBO will be unbound after this call.
132   //! @param theComponentsNb - specifies the number of components per generic vertex attribute; must be 1, 2, 3, or 4;
133   //! @param theElemsNb      - elements count;
134   //! @param theData         - pointer to GLubyte data (indices/colors etc.).
135   bool Init (const Handle(OpenGl_Context)& theGlCtx,
136              const GLuint   theComponentsNb,
137              const GLsizei  theElemsNb,
138              const GLubyte* theData)
139   {
140     return init (theGlCtx, theComponentsNb, theElemsNb, theData, GL_UNSIGNED_BYTE);
141   }
142
143   //! Notice that VBO will be unbound after this call.
144   //! Function replaces portion of data within this VBO using glBufferSubData().
145   //! The VBO should be initialized before call.
146   //! @param theElemFrom - element id from which replace buffer data (>=0);
147   //! @param theElemsNb  - elements count (theElemFrom + theElemsNb <= GetElemsNb());
148   //! @param theData     - pointer to GLfloat data.
149   bool SubData (const Handle(OpenGl_Context)& theGlCtx,
150                 const GLsizei  theElemFrom,
151                 const GLsizei  theElemsNb,
152                 const GLfloat* theData)
153   {
154     return subData (theGlCtx, theElemFrom, theElemsNb, theData, GL_FLOAT);
155   }
156
157   //! Notice that VBO will be unbound after this call.
158   //! Function replaces portion of data within this VBO using glBufferSubData().
159   //! The VBO should be initialized before call.
160   //! @param theElemFrom element id from which replace buffer data (>=0);
161   //! @param theElemsNb  elements count (theElemFrom + theElemsNb <= GetElemsNb());
162   //! @param theData     pointer to GLuint data.
163   bool SubData (const Handle(OpenGl_Context)& theGlCtx,
164                 const GLsizei theElemFrom,
165                 const GLsizei theElemsNb,
166                 const GLuint* theData)
167   {
168     return subData (theGlCtx, theElemFrom, theElemsNb, theData, GL_UNSIGNED_INT);
169   }
170
171   //! Notice that VBO will be unbound after this call.
172   //! Function replaces portion of data within this VBO using glBufferSubData().
173   //! The VBO should be initialized before call.
174   //! @param theElemFrom element id from which replace buffer data (>=0);
175   //! @param theElemsNb  elements count (theElemFrom + theElemsNb <= GetElemsNb());
176   //! @param theData     pointer to GLushort data.
177   bool SubData (const Handle(OpenGl_Context)& theGlCtx,
178                 const GLsizei   theElemFrom,
179                 const GLsizei   theElemsNb,
180                 const GLushort* theData)
181   {
182     return subData (theGlCtx, theElemFrom, theElemsNb, theData, GL_UNSIGNED_SHORT);
183   }
184
185   //! Notice that VBO will be unbound after this call.
186   //! Function replaces portion of data within this VBO using glBufferSubData().
187   //! The VBO should be initialized before call.
188   //! @param theElemFrom element id from which replace buffer data (>=0);
189   //! @param theElemsNb  elements count (theElemFrom + theElemsNb <= GetElemsNb());
190   //! @param theData     pointer to GLubyte data.
191   bool SubData (const Handle(OpenGl_Context)& theGlCtx,
192                 const GLsizei  theElemFrom,
193                 const GLsizei  theElemsNb,
194                 const GLubyte* theData)
195   {
196     return subData (theGlCtx, theElemFrom, theElemsNb, theData, GL_UNSIGNED_BYTE);
197   }
198
199   //! Bind this VBO to active GLSL program.
200   Standard_EXPORT void BindVertexAttrib (const Handle(OpenGl_Context)& theGlCtx,
201                                          const GLuint                  theAttribLoc) const;
202
203   //! Unbind any VBO from active GLSL program.
204   Standard_EXPORT void UnbindVertexAttrib (const Handle(OpenGl_Context)& theGlCtx,
205                                            const GLuint                  theAttribLoc) const;
206
207   //! Bind this VBO and enable specified attribute in OpenGl_Context::ActiveProgram() or FFP.
208   //! @param theGlCtx - handle to bound GL context;
209   //! @param theMode  - array mode (GL_VERTEX_ARRAY, GL_NORMAL_ARRAY, GL_COLOR_ARRAY, GL_INDEX_ARRAY, GL_TEXTURE_COORD_ARRAY).
210   void BindAttribute (const Handle(OpenGl_Context)&   theCtx,
211                       const Graphic3d_TypeOfAttribute theMode) const
212   {
213     if (IsValid())
214     {
215       Bind (theCtx);
216       bindAttribute (theCtx, theMode, static_cast<GLint> (myComponentsNb), myDataType, 0, myOffset);
217     }
218   }
219
220   //! Unbind this VBO and disable specified attribute in OpenGl_Context::ActiveProgram() or FFP.
221   //! @param theCtx handle to bound GL context
222   //! @param theMode  array mode
223   void UnbindAttribute (const Handle(OpenGl_Context)&   theCtx,
224                         const Graphic3d_TypeOfAttribute theMode) const
225   {
226     if (IsValid())
227     {
228       Unbind (theCtx);
229       unbindAttribute (theCtx, theMode);
230     }
231   }
232
233 public: //! @name advanced methods
234
235   //! Returns estimated GPU memory usage for holding data without considering overheads and allocation alignment rules.
236   virtual Standard_Size EstimatedDataSize() const Standard_OVERRIDE
237   {
238     return IsValid()
239          ? sizeOfGlType (myDataType) * myComponentsNb * myElemsNb
240          : 0;
241   }
242
243   //! @return size of specified GL type
244   static size_t sizeOfGlType (const GLenum theType)
245   {
246     switch (theType)
247     {
248       case GL_BYTE:
249       case GL_UNSIGNED_BYTE:  return sizeof(GLubyte);
250       case GL_SHORT:
251       case GL_UNSIGNED_SHORT: return sizeof(GLushort);
252     #ifdef GL_INT
253       case GL_INT:
254     #endif
255       case GL_UNSIGNED_INT:   return sizeof(GLuint);
256       case GL_FLOAT:          return sizeof(GLfloat);
257     #ifdef GL_DOUBLE
258       case GL_DOUBLE:         return sizeof(GLdouble);
259     #endif
260       default:                return 0;
261     }
262   }
263
264   //! Initialize buffer with new data.
265   Standard_EXPORT virtual bool init (const Handle(OpenGl_Context)& theGlCtx,
266                                      const GLuint   theComponentsNb,
267                                      const GLsizei  theElemsNb,
268                                      const void*    theData,
269                                      const GLenum   theDataType,
270                                      const GLsizei  theStride);
271
272   //! Initialize buffer with new data.
273   bool init (const Handle(OpenGl_Context)& theGlCtx,
274              const GLuint   theComponentsNb,
275              const GLsizei  theElemsNb,
276              const void*    theData,
277              const GLenum   theDataType)
278   {
279     return init (theGlCtx, theComponentsNb, theElemsNb, theData, theDataType, GLsizei(theComponentsNb) * GLsizei(sizeOfGlType (theDataType)));
280   }
281
282   //! Update part of the buffer with new data.
283   Standard_EXPORT virtual bool subData (const Handle(OpenGl_Context)& theGlCtx,
284                                         const GLsizei  theElemFrom,
285                                         const GLsizei  theElemsNb,
286                                         const void*    theData,
287                                         const GLenum   theDataType);
288
289   //! Setup array pointer - either for active GLSL program OpenGl_Context::ActiveProgram()
290   //! or for FFP using bindFixed() when no program bound.
291   static void bindAttribute (const Handle(OpenGl_Context)&   theGlCtx,
292                              const Graphic3d_TypeOfAttribute theMode,
293                              const GLint                     theNbComp,
294                              const GLenum                    theDataType,
295                              const GLsizei                   theStride,
296                              const GLvoid*                   theOffset);
297
298   //! Disable GLSL array pointer - either for active GLSL program OpenGl_Context::ActiveProgram()
299   //! or for FFP using unbindFixed() when no program bound.
300   static void unbindAttribute (const Handle(OpenGl_Context)&   theGlCtx,
301                                const Graphic3d_TypeOfAttribute theMode);
302
303 private:
304 #if !defined(GL_ES_VERSION_2_0)
305   //! Setup FFP array pointer.
306   static void bindFixed (const Handle(OpenGl_Context)&   theGlCtx,
307                          const Graphic3d_TypeOfAttribute theMode,
308                          const GLint                     theNbComp,
309                          const GLenum                    theDataType,
310                          const GLsizei                   theStride,
311                          const GLvoid*                   theOffset);
312
313   //! Disable FFP array pointer.
314   static void unbindFixed (const Handle(OpenGl_Context)&   theGlCtx,
315                            const Graphic3d_TypeOfAttribute theMode);
316
317   //! Disable FFP color array pointer.
318   Standard_EXPORT static void unbindFixedColor (const Handle(OpenGl_Context)& theCtx);
319
320 #endif
321 public: //! @name methods for interleaved attributes array
322
323   //! @return true if buffer contains per-vertex color attribute
324   Standard_EXPORT virtual bool HasColorAttribute() const;
325
326   //! @return true if buffer contains per-vertex normal attribute
327   Standard_EXPORT virtual bool HasNormalAttribute() const;
328
329   //! Bind all vertex attributes to active program OpenGl_Context::ActiveProgram() or for FFP.
330   //! Default implementation does nothing.
331   Standard_EXPORT virtual void BindAllAttributes (const Handle(OpenGl_Context)& theGlCtx) const;
332
333   //! Bind vertex position attribute only. Default implementation does nothing.
334   Standard_EXPORT virtual void BindPositionAttribute (const Handle(OpenGl_Context)& theGlCtx) const;
335
336   //! Unbind all vertex attributes. Default implementation does nothing.
337   Standard_EXPORT virtual void UnbindAllAttributes (const Handle(OpenGl_Context)& theGlCtx) const;
338
339 protected:
340
341   GLubyte* myOffset;       //!< offset to data
342   GLuint   myBufferId;     //!< VBO name (index)
343   GLuint   myComponentsNb; //!< Number of components per generic vertex attribute, must be 1, 2, 3, or 4
344   GLsizei  myElemsNb;      //!< Number of vertex attributes / number of vertices
345   GLenum   myDataType;     //!< Data type (GL_FLOAT, GL_UNSIGNED_INT, GL_UNSIGNED_BYTE etc.)
346
347 public:
348
349   DEFINE_STANDARD_RTTIEXT(OpenGl_VertexBuffer,OpenGl_Resource) // Type definition
350
351 };
352
353 DEFINE_STANDARD_HANDLE(OpenGl_VertexBuffer, OpenGl_Resource)
354
355 #include <OpenGl_VertexBuffer.lxx>
356
357 #endif // _OpenGl_VertexBuffer_H__