0024322: TKOpenGl - light sources management inconsistency
[occt.git] / src / OpenGl / OpenGl_ShaderProgram.hxx
1 // Created on: 2013-09-19
2 // Created by: Denis BOGOLEPOV
3 // Copyright (c) 2013 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 #ifndef _OpenGl_ShaderProgram_Header
21 #define _OpenGl_ShaderProgram_Header
22
23 #include <NCollection_DataMap.hxx>
24 #include <NCollection_Sequence.hxx>
25 #include <TCollection_AsciiString.hxx>
26
27 #include <Graphic3d_ShaderObject.hxx>
28 #include <Graphic3d_ShaderProgram.hxx>
29
30 #include <InterfaceGraphic_tgl_all.hxx>
31
32 #include <OpenGl_Vec.hxx>
33 #include <OpenGl_Matrix.hxx>
34 #include <OpenGl_ShaderObject.hxx>
35 #include <Handle_OpenGl_ShaderProgram.hxx>
36
37 //! The enumeration of OCCT-specific OpenGL/GLSL variables.
38 enum OpenGl_StateVariable
39 {
40   // OpenGL matrix state
41   OpenGl_OCC_MODEL_WORLD_MATRIX,
42   OpenGl_OCC_WORLD_VIEW_MATRIX,
43   OpenGl_OCC_PROJECTION_MATRIX,
44   OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE,
45   OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE,
46   OpenGl_OCC_PROJECTION_MATRIX_INVERSE,
47   OpenGl_OCC_MODEL_WORLD_MATRIX_TRANSPOSE,
48   OpenGl_OCC_WORLD_VIEW_MATRIX_TRANSPOSE,
49   OpenGl_OCC_PROJECTION_MATRIX_TRANSPOSE,
50   OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE_TRANSPOSE,
51   OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE_TRANSPOSE,
52   OpenGl_OCC_PROJECTION_MATRIX_INVERSE_TRANSPOSE,
53
54   // OpenGL clip planes state
55   OpenGl_OCC_CLIP_PLANE_EQUATIONS,
56   OpenGl_OCC_CLIP_PLANE_SPACES,
57
58   // OpenGL light state
59   OpenGl_OCC_LIGHT_SOURCE_COUNT,
60   OpenGl_OCC_LIGHT_SOURCE_TYPES,
61   OpenGl_OCC_LIGHT_SOURCE_PARAMS,
62   OpenGl_OCC_LIGHT_AMBIENT,
63
64   // Material state
65   OpenGl_OCCT_ACTIVE_SAMPLER,
66   OpenGl_OCCT_TEXTURE_ENABLE,
67   OpenGl_OCCT_DISTINGUISH_MODE,
68   OpenGl_OCCT_FRONT_MATERIAL,
69   OpenGl_OCCT_BACK_MATERIAL,
70
71   // DON'T MODIFY THIS ITEM (insert new items before it)
72   OpenGl_OCCT_NUMBER_OF_STATE_VARIABLES
73 };
74
75 class OpenGl_ShaderProgram;
76
77 //! Interface for generic setter of user-defined uniform variables.
78 struct OpenGl_SetterInterface
79 {
80   //! Sets user-defined uniform variable to specified program.
81   virtual void Set (const Handle(OpenGl_Context)&           theCtx,
82                     const Handle(Graphic3d_ShaderVariable)& theVariable,
83                     OpenGl_ShaderProgram*                   theProgram) = 0;
84
85   //! Destructor
86   virtual ~OpenGl_SetterInterface() {}
87 };
88
89 //! List of OpenGL shader objects.
90 typedef NCollection_Sequence<Handle(OpenGl_ShaderObject)>    OpenGl_ShaderList;
91
92 //! List of shader variable setters.
93 typedef NCollection_DataMap<size_t, OpenGl_SetterInterface*> OpenGl_SetterList;
94
95 //! Support tool for setting user-defined uniform variables.
96 class OpenGl_VariableSetterSelector
97 {
98 public:
99
100   //! Creates new setter selector.
101   OpenGl_VariableSetterSelector();
102
103   //! Releases memory resources of setter selector.
104   ~OpenGl_VariableSetterSelector();
105
106   //! Sets user-defined uniform variable to specified program.
107   void Set (const Handle(OpenGl_Context)&           theCtx,
108             const Handle(Graphic3d_ShaderVariable)& theVariable,
109             OpenGl_ShaderProgram*                   theProgram) const;
110
111 private:
112
113   //! List of variable setters.
114   OpenGl_SetterList mySetterList;
115 };
116
117 //! Defines types of uniform state variables.
118 enum OpenGl_UniformStateType
119 {
120   OpenGl_LIGHT_SOURCES_STATE,
121   OpenGl_CLIP_PLANES_STATE,
122   OpenGl_MODEL_WORLD_STATE,
123   OpenGl_WORLD_VIEW_STATE,
124   OpenGl_PROJECTION_STATE,
125   OpenGl_MATERIALS_STATE
126 };
127
128 //! Total number of state types.
129 const int MaxStateTypes = 6;
130
131 //! Wrapper for OpenGL program object.
132 class OpenGl_ShaderProgram : public OpenGl_Resource
133 {
134
135 public:
136
137   //! Non-valid shader name.
138   static const GLuint NO_PROGRAM = 0;
139
140   //! Invalid location of uniform/attribute variable.
141   static const GLint INVALID_LOCATION = -1;
142
143   //! List of pre-defined OCCT state uniform variables.
144   static Standard_CString PredefinedKeywords[OpenGl_OCCT_NUMBER_OF_STATE_VARIABLES];
145
146 protected:
147
148   //! Creates uninitialized shader program.
149   Standard_EXPORT OpenGl_ShaderProgram (const Handle(Graphic3d_ShaderProgram)& theProxy = NULL);
150
151   static OpenGl_VariableSetterSelector mySetterSelector;
152
153 public:
154
155   //! Releases resources of shader program.
156   Standard_EXPORT virtual ~OpenGl_ShaderProgram();
157
158   //! Creates new empty shader program of specified type.
159   Standard_EXPORT Standard_Boolean Create (const Handle(OpenGl_Context)& theCtx);
160
161   //! Destroys shader program.
162   Standard_EXPORT virtual void Release (const OpenGl_Context* theCtx);
163
164   //! Attaches shader object to the program object.
165   Standard_EXPORT Standard_Boolean AttachShader (const Handle(OpenGl_Context)&      theCtx,
166                                                  const Handle(OpenGl_ShaderObject)& theShader);
167
168   //! Detaches shader object to the program object.
169   Standard_EXPORT Standard_Boolean DetachShader (const Handle(OpenGl_Context)&      theCtx,
170                                                  const Handle(OpenGl_ShaderObject)& theShader);
171
172   //! Initializes program object with the list of shader objects.
173   Standard_EXPORT Standard_Boolean Initialize (const Handle(OpenGl_Context)&     theCtx,
174                                                const Graphic3d_ShaderObjectList& theShaders);
175
176   //! Links the program object.
177   Standard_EXPORT Standard_Boolean Link (const Handle(OpenGl_Context)& theCtx);
178
179   //! Fetches information log of the last link operation.
180   Standard_EXPORT Standard_Boolean FetchInfoLog (const Handle(OpenGl_Context)& theCtx,
181                                                  TCollection_AsciiString&      theLog);
182
183   //! Fetches uniform variables from proxy shader program.
184   Standard_EXPORT Standard_Boolean ApplyVariables (const Handle(OpenGl_Context)& theCtx);
185
186   //! Sets the program object as part of current rendering state.
187   Standard_EXPORT void Bind (const Handle(OpenGl_Context)& theCtx) const;
188
189   //! Binds the program object and applies variables from proxy shader program.
190   Standard_EXPORT Standard_Boolean BindWithVariables (const Handle(OpenGl_Context)& theCtx);
191
192   //! Reverts to fixed-function graphics pipeline (FFP).
193   Standard_EXPORT static void Unbind (const Handle(OpenGl_Context)& theCtx);
194
195   //! @return true if current object was initialized
196   inline bool IsValid() const
197   {
198     return myProgramID != NO_PROGRAM;
199   }
200
201 private:
202
203   //! Returns index of last modification of variables of specified state type.
204   Standard_EXPORT Standard_Size ActiveState (const OpenGl_UniformStateType theType) const;
205
206   //! Updates index of last modification of variables of specified state type.
207   Standard_EXPORT void UpdateState (const OpenGl_UniformStateType theType,
208                                     const Standard_Size           theIndex);
209
210 public:
211
212   //! Returns location of the specific uniform variable.
213   Standard_EXPORT GLint GetUniformLocation (const Handle(OpenGl_Context)& theCtx,
214                                             const GLchar*                 theName) const;
215
216   //! Returns index of the generic vertex attribute by variable name.
217   Standard_EXPORT GLint GetAttributeLocation (const Handle(OpenGl_Context)& theCtx,
218                                               const GLchar*                 theName) const;
219
220   //! Returns location of the OCCT state uniform variable.
221   Standard_EXPORT GLint GetStateLocation (const GLuint theVariable) const;
222
223 public:
224
225   //! Returns the value of the integer uniform variable.
226   Standard_EXPORT Standard_Boolean GetUniform (const Handle(OpenGl_Context)& theCtx,
227                                                const GLchar*                 theName,
228                                                OpenGl_Vec4i&                 theValue) const;
229
230   Standard_EXPORT Standard_Boolean GetUniform (const Handle(OpenGl_Context)& theCtx,
231                                                GLint                         theLocation,
232                                                OpenGl_Vec4i&                 theValue) const;
233
234   //! Returns the value of the float uniform variable.
235   Standard_EXPORT Standard_Boolean GetUniform (const Handle(OpenGl_Context)& theCtx,
236                                                const GLchar*                 theName,
237                                                OpenGl_Vec4&                  theValue) const;
238
239   //! Returns the value of the float uniform variable.
240   Standard_EXPORT Standard_Boolean GetUniform (const Handle(OpenGl_Context)& theCtx,
241                                                GLint                         theLocation,
242                                                OpenGl_Vec4&                  theValue) const;
243
244 public:
245
246   //! Returns the integer vertex attribute.
247   Standard_EXPORT Standard_Boolean GetAttribute (const Handle(OpenGl_Context)& theCtx,
248                                                  const GLchar*                 theName,
249                                                  OpenGl_Vec4i&                 theValue) const;
250
251   //! Returns the integer vertex attribute.
252   Standard_EXPORT Standard_Boolean GetAttribute (const Handle(OpenGl_Context)& theCtx,
253                                                  GLint                         theIndex,
254                                                  OpenGl_Vec4i&                 theValue) const;
255
256   //! Returns the float vertex attribute.
257   Standard_EXPORT Standard_Boolean GetAttribute (const Handle(OpenGl_Context)& theCtx,
258                                                  const GLchar*                 theName,
259                                                  OpenGl_Vec4&                  theValue) const;
260
261   //! Returns the float vertex attribute.
262   Standard_EXPORT Standard_Boolean GetAttribute (const Handle(OpenGl_Context)& theCtx,
263                                                  GLint                         theIndex,
264                                                  OpenGl_Vec4&                  theValue) const;
265
266 public:
267
268   //! Specifies the value of the integer uniform variable.
269   Standard_EXPORT Standard_Boolean SetUniform (const Handle(OpenGl_Context)& theCtx,
270                                                const GLchar*                 theName,
271                                                GLint                         theValue);
272
273   //! Specifies the value of the integer uniform variable.
274   Standard_EXPORT Standard_Boolean SetUniform (const Handle(OpenGl_Context)& theCtx,
275                                                GLint                         theLocation,
276                                                GLint                         theValue);
277
278   //! Specifies the value of the integer uniform 2D vector.
279   Standard_EXPORT Standard_Boolean SetUniform (const Handle(OpenGl_Context)& theCtx,
280                                                const GLchar*                 theName,
281                                                const OpenGl_Vec2i&           theValue);
282
283   //! Specifies the value of the integer uniform 2D vector.
284   Standard_EXPORT Standard_Boolean SetUniform (const Handle(OpenGl_Context)& theCtx,
285                                                GLint                         theLocation,
286                                                const OpenGl_Vec2i&           theValue);
287
288   //! Specifies the value of the integer uniform 3D vector.
289   Standard_EXPORT Standard_Boolean SetUniform (const Handle(OpenGl_Context)& theCtx,
290                                                const GLchar*                 theName,
291                                                const OpenGl_Vec3i&           theValue);
292
293   //! Specifies the value of the integer uniform 3D vector.
294   Standard_EXPORT Standard_Boolean SetUniform (const Handle(OpenGl_Context)& theCtx,
295                                                GLint                         theLocation,
296                                                const OpenGl_Vec3i&           theValue);
297
298   //! Specifies the value of the integer uniform 4D vector.
299   Standard_EXPORT Standard_Boolean SetUniform (const Handle(OpenGl_Context)& theCtx,
300                                                const GLchar*                 theName,
301                                                const OpenGl_Vec4i&           theValue);
302
303   //! Specifies the value of the integer uniform 4D vector.
304   Standard_EXPORT Standard_Boolean SetUniform (const Handle(OpenGl_Context)& theCtx,
305                                                GLint                         theLocation,
306                                                const OpenGl_Vec4i&           theValue);
307
308 public:
309
310   //! Specifies the value of the float uniform variable.
311   Standard_EXPORT Standard_Boolean SetUniform (const Handle(OpenGl_Context)& theCtx,
312                                                const GLchar*                 theName,
313                                                GLfloat                       theValue);
314
315   //! Specifies the value of the float uniform variable.
316   Standard_EXPORT Standard_Boolean SetUniform (const Handle(OpenGl_Context)& theCtx,
317                                                GLint                         theLocation,
318                                                GLfloat                       theValue);
319
320   //! Specifies the value of the float uniform 2D vector.
321   Standard_EXPORT Standard_Boolean SetUniform (const Handle(OpenGl_Context)& theCtx,
322                                                const GLchar*                 theName,
323                                                const OpenGl_Vec2&            theValue);
324
325   //! Specifies the value of the float uniform 2D vector.
326   Standard_EXPORT Standard_Boolean SetUniform (const Handle(OpenGl_Context)& theCtx,
327                                                GLint                         theLocation,
328                                                const OpenGl_Vec2&            theValue);
329
330   //! Specifies the value of the float uniform 3D vector.
331   Standard_EXPORT Standard_Boolean SetUniform (const Handle(OpenGl_Context)& theCtx,
332                                                const GLchar*                 theName,
333                                                const OpenGl_Vec3&            theValue);
334
335   //! Specifies the value of the float uniform 3D vector.
336   Standard_EXPORT Standard_Boolean SetUniform (const Handle(OpenGl_Context)& theCtx,
337                                                GLint                         theLocation,
338                                                const OpenGl_Vec3&            theValue);
339
340   //! Specifies the value of the float uniform 4D vector.
341   Standard_EXPORT Standard_Boolean SetUniform (const Handle(OpenGl_Context)& theCtx,
342                                                const GLchar*                 theName,
343                                                const OpenGl_Vec4&            theValue);
344
345   //! Specifies the value of the float uniform 4D vector.
346   Standard_EXPORT Standard_Boolean SetUniform (const Handle(OpenGl_Context)& theCtx,
347                                                GLint                         theLocation,
348                                                const OpenGl_Vec4&            theValue);
349
350 public:
351
352   //! Specifies the value of the float uniform 4x4 matrix.
353   Standard_EXPORT Standard_Boolean SetUniform (const Handle(OpenGl_Context)& theCtx,
354                                                const GLchar*                 theName,
355                                                const OpenGl_Matrix&          theValue,
356                                                GLboolean                     theTranspose = GL_FALSE);
357
358   //! Specifies the value of the float uniform 4x4 matrix.
359   Standard_EXPORT Standard_Boolean SetUniform (const Handle(OpenGl_Context)& theCtx,
360                                                GLint                         theLocation,
361                                                const OpenGl_Matrix&          theValue,
362                                                GLboolean                     theTranspose = GL_FALSE);
363
364   //! Specifies the value of the float uniform 4x4 matrix.
365   Standard_EXPORT Standard_Boolean SetUniform (const Handle(OpenGl_Context)& theCtx,
366                                                const GLchar*                 theName,
367                                                const Tmatrix3&               theValue,
368                                                GLboolean                     theTranspose = GL_FALSE);
369
370   //! Specifies the value of the float uniform 4x4 matrix.
371   Standard_EXPORT Standard_Boolean SetUniform (const Handle(OpenGl_Context)& theCtx,
372                                                GLint                         theLocation,
373                                                const Tmatrix3&               theValue,
374                                                GLboolean                     theTranspose = GL_FALSE);
375
376   //! Specifies the value of the float uniform array
377   Standard_EXPORT Standard_Boolean SetUniform (const Handle(OpenGl_Context)& theCtx,
378                                                GLint                         theLocation,
379                                                GLuint                        theCount,
380                                                const Standard_ShortReal*     theData);
381
382   //! Specifies the value of the float2 uniform array
383   Standard_EXPORT Standard_Boolean SetUniform (const Handle(OpenGl_Context)& theCtx,
384                                                GLint                         theLocation,
385                                                GLuint                        theCount,
386                                                const OpenGl_Vec2*            theData);
387
388   //! Specifies the value of the float3 uniform array
389   Standard_EXPORT Standard_Boolean SetUniform (const Handle(OpenGl_Context)& theCtx,
390                                                GLint                         theLocation,
391                                                GLuint                        theCount,
392                                                const OpenGl_Vec3*            theData);
393
394   //! Specifies the value of the float4 uniform array
395   Standard_EXPORT Standard_Boolean SetUniform (const Handle(OpenGl_Context)& theCtx,
396                                                GLint                         theLocation,
397                                                GLuint                        theCount,
398                                                const OpenGl_Vec4*            theData);
399
400   //! Specifies the value of the integer uniform array
401   Standard_EXPORT Standard_Boolean SetUniform (const Handle(OpenGl_Context)& theCtx,
402                                                GLint                         theLocation,
403                                                GLuint                        theCount,
404                                                const Standard_Integer*       theData);
405
406   //! Specifies the value of the int2 uniform array
407   Standard_EXPORT Standard_Boolean SetUniform (const Handle(OpenGl_Context)& theCtx,
408                                                GLint                         theLocation,
409                                                GLuint                        theCount,
410                                                const OpenGl_Vec2i*           theData);
411
412   //! Specifies the value of the int3 uniform array
413   Standard_EXPORT Standard_Boolean SetUniform (const Handle(OpenGl_Context)& theCtx,
414                                                GLint                         theLocation,
415                                                GLuint                        theCount,
416                                                const OpenGl_Vec3i*           theData);
417
418   //! Specifies the value of the int4 uniform array
419   Standard_EXPORT Standard_Boolean SetUniform (const Handle(OpenGl_Context)& theCtx,
420                                                GLint                         theLocation,
421                                                GLuint                        theCount,
422                                                const OpenGl_Vec4i*           theData);
423
424 public:
425
426   //! Specifies the value of the sampler uniform variable.
427   Standard_EXPORT Standard_Boolean SetSampler (const Handle(OpenGl_Context)& theCtx,
428                                                const GLchar*                 theName,
429                                                const GLenum                  theTextureUnit);
430
431   //! Specifies the value of the sampler uniform variable.
432   Standard_EXPORT Standard_Boolean SetSampler (const Handle(OpenGl_Context)& theCtx,
433                                                GLint                         theLocation,
434                                                const GLenum                  theTextureUnit);
435
436 protected:
437
438   //! Increments counter of users.
439   //! Used by OpenGl_ShaderManager.
440   //! @return true when resource has been restored from delayed release queue
441   bool Share()
442   {
443     return ++myShareCount == 1;
444   }
445
446   //! Decrements counter of users.
447   //! Used by OpenGl_ShaderManager.
448   //! @return true when there are no more users of this program has been left
449   bool UnShare()
450   {
451     return --myShareCount == 0;
452   }
453
454 protected:
455
456   GLuint                          myProgramID;     //!< Handle of OpenGL shader program
457   OpenGl_ShaderList               myShaderObjects; //!< List of attached shader objects
458   Handle(Graphic3d_ShaderProgram) myProxy;         //!< Proxy shader program (from application layer)
459   Standard_Integer                myShareCount;    //!< program users count, initialized with 1 (already shared by one user)
460
461 protected:
462
463   //! Defines last modification for variables of each state type.
464   Standard_Size myCurrentState[MaxStateTypes];
465
466   //! Stores locations of OCCT state uniform variables.
467   GLint myStateLocations[OpenGl_OCCT_NUMBER_OF_STATE_VARIABLES];
468
469 public:
470
471   DEFINE_STANDARD_RTTI (OpenGl_ShaderProgram)
472   friend class OpenGl_ShaderManager;
473
474 };
475
476 template<class T>
477 struct OpenGl_VariableSetter : public OpenGl_SetterInterface
478 {
479   virtual void Set (const Handle(OpenGl_Context)&           theCtx,
480                     const Handle(Graphic3d_ShaderVariable)& theVariable,
481                     OpenGl_ShaderProgram*                   theProgram)
482   {
483     theProgram->SetUniform (theCtx,
484                             theVariable->Name().ToCString(),
485                             theVariable->Value()->As<T>());
486   }
487 };
488
489 namespace OpenGl_HashMapInitializer
490 {
491   template<class K, class V>
492   struct MapListOfType
493   {
494     NCollection_DataMap<K, V> myDictionary;
495
496     MapListOfType (K theKey, V theValue)
497     {
498       myDictionary.Bind (theKey, theValue);
499     }
500
501     MapListOfType& operator() (K theKey, V theValue)
502     {
503       myDictionary.Bind (theKey, theValue);
504       return *this;
505     }
506
507     operator const NCollection_DataMap<K, V>& () const
508     {
509       return myDictionary;
510     }
511   };
512
513   template<class K, class V>
514   MapListOfType<K, V> CreateListOf (K theKey, V theValue)
515   {
516     return MapListOfType<K, V> (theKey, theValue);
517   }
518 }
519
520 #endif // _OpenGl_ShaderProgram_Header