0024739: TKOpenGl - port ray-tracing from OpenCL to GLSL for better integration and...
[occt.git] / src / OpenGl / OpenGl_ShaderProgram.cxx
1 // Created on: 2013-09-19
2 // Created by: Denis BOGOLEPOV
3 // Copyright (c) 2013-2014 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 <OSD_File.hxx>
17 #include <OSD_Protection.hxx>
18
19 #include <Standard_Assert.hxx>
20 #include <Standard_Atomic.hxx>
21 #include <TCollection_ExtendedString.hxx>
22
23 #include <OpenGl_Context.hxx>
24 #include <OpenGl_ShaderProgram.hxx>
25 #include <OpenGl_ShaderManager.hxx>
26
27 IMPLEMENT_STANDARD_HANDLE (OpenGl_ShaderProgram, OpenGl_Resource)
28 IMPLEMENT_STANDARD_RTTIEXT(OpenGl_ShaderProgram, OpenGl_Resource)
29
30 OpenGl_VariableSetterSelector OpenGl_ShaderProgram::mySetterSelector = OpenGl_VariableSetterSelector();
31
32 // Declare OCCT-specific OpenGL/GLSL shader variables
33 Standard_CString OpenGl_ShaderProgram::PredefinedKeywords[] =
34 {
35   "occModelWorldMatrix",                 // OpenGl_OCC_MODEL_WORLD_MATRIX
36   "occWorldViewMatrix",                  // OpenGl_OCC_WORLD_VIEW_MATRIX
37   "occProjectionMatrix",                 // OpenGl_OCC_PROJECTION_MATRIX
38   "occModelWorldMatrixInverse",          // OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE
39   "occWorldViewMatrixInverse",           // OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE
40   "occProjectionMatrixInverse",          // OpenGl_OCC_PROJECTION_MATRIX_INVERSE
41   "occModelWorldMatrixTranspose",        // OpenGl_OCC_MODEL_WORLD_MATRIX_TRANSPOSE
42   "occWorldViewMatrixTranspose",         // OpenGl_OCC_WORLD_VIEW_MATRIX_TRANSPOSE
43   "occProjectionMatrixTranspose",        // OpenGl_OCC_PROJECTION_MATRIX_TRANSPOSE
44   "occModelWorldMatrixInverseTranspose", // OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE_TRANSPOSE
45   "occWorldViewMatrixInverseTranspose",  // OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE_TRANSPOSE
46   "occProjectionMatrixInverseTranspose", // OpenGl_OCC_PROJECTION_MATRIX_INVERSE_TRANSPOSE
47
48   "occClipPlaneEquations", // OpenGl_OCC_CLIP_PLANE_EQUATIONS
49   "occClipPlaneSpaces",    // OpenGl_OCC_CLIP_PLANE_SPACES
50   "occClipPlaneCount",     // OpenGl_OCC_CLIP_PLANE_COUNT
51
52   "occLightSourcesCount",  // OpenGl_OCC_LIGHT_SOURCE_COUNT
53   "occLightSourcesTypes",  // OpenGl_OCC_LIGHT_SOURCE_TYPES
54   "occLightSources",       // OpenGl_OCC_LIGHT_SOURCE_PARAMS
55   "occLightAmbient",       // OpenGl_OCC_LIGHT_AMBIENT
56
57   "occActiveSampler",      // OpenGl_OCCT_ACTIVE_SAMPLER
58   "occTextureEnable",      // OpenGl_OCCT_TEXTURE_ENABLE
59   "occDistinguishingMode", // OpenGl_OCCT_DISTINGUISH_MODE
60   "occFrontMaterial",      // OpenGl_OCCT_FRONT_MATERIAL
61   "occBackMaterial"        // OpenGl_OCCT_BACK_MATERIAL
62
63 };
64
65 // =======================================================================
66 // function : OpenGl_VariableSetterSelector
67 // purpose  : Creates new variable setter selector
68 // =======================================================================
69 OpenGl_VariableSetterSelector::OpenGl_VariableSetterSelector()
70 {
71   // Note: Add new variable setters here
72   mySetterList = OpenGl_HashMapInitializer::CreateListOf<size_t, OpenGl_SetterInterface*>
73     (Graphic3d_UniformValueTypeID<int>::ID,          new OpenGl_VariableSetter<int>())
74     (Graphic3d_UniformValueTypeID<float>::ID,        new OpenGl_VariableSetter<float>())
75     (Graphic3d_UniformValueTypeID<OpenGl_Vec2>::ID,  new OpenGl_VariableSetter<OpenGl_Vec2>())
76     (Graphic3d_UniformValueTypeID<OpenGl_Vec3>::ID,  new OpenGl_VariableSetter<OpenGl_Vec3>())
77     (Graphic3d_UniformValueTypeID<OpenGl_Vec4>::ID,  new OpenGl_VariableSetter<OpenGl_Vec4>())
78     (Graphic3d_UniformValueTypeID<OpenGl_Vec2i>::ID, new OpenGl_VariableSetter<OpenGl_Vec2i>())
79     (Graphic3d_UniformValueTypeID<OpenGl_Vec3i>::ID, new OpenGl_VariableSetter<OpenGl_Vec3i>())
80     (Graphic3d_UniformValueTypeID<OpenGl_Vec4i>::ID, new OpenGl_VariableSetter<OpenGl_Vec4i>());
81 }
82
83 // =======================================================================
84 // function : ~OpenGl_VariableSetterSelector
85 // purpose  : Releases memory resources of variable setter selector
86 // =======================================================================
87 OpenGl_VariableSetterSelector::~OpenGl_VariableSetterSelector()
88 {
89   for (OpenGl_SetterList::Iterator anIt (mySetterList); anIt.More(); anIt.Next())
90   {
91     delete anIt.Value();
92   }
93
94   mySetterList.Clear();
95 }
96
97 // =======================================================================
98 // function : Set
99 // purpose  : Sets generic variable to specified shader program
100 // =======================================================================
101 void OpenGl_VariableSetterSelector::Set (const Handle(OpenGl_Context)&           theCtx,
102                                          const Handle(Graphic3d_ShaderVariable)& theVariable,
103                                          OpenGl_ShaderProgram*                   theProgram) const
104 {
105   Standard_ASSERT_RETURN (mySetterList.IsBound (theVariable->Value()->TypeID()),
106     "The type of user-defined uniform variable is not supported...", );
107
108   mySetterList.Find (theVariable->Value()->TypeID())->Set (theCtx, theVariable, theProgram);
109 }
110
111 // =======================================================================
112 // function : OpenGl_ShaderProgram
113 // purpose  : Creates uninitialized shader program
114 // =======================================================================
115 OpenGl_ShaderProgram::OpenGl_ShaderProgram (const Handle(Graphic3d_ShaderProgram)& theProxy)
116 : myProgramID (NO_PROGRAM),
117   myProxy     (theProxy),
118   myShareCount(1)
119 {
120   memset (myCurrentState, 0, sizeof (myCurrentState));
121   for (GLint aVar = 0; aVar < OpenGl_OCCT_NUMBER_OF_STATE_VARIABLES; ++aVar)
122   {
123     myStateLocations[aVar] = INVALID_LOCATION;
124   }
125 }
126
127 // =======================================================================
128 // function : Initialize
129 // purpose  : Initializes program object with the list of shader objects
130 // =======================================================================
131 Standard_Boolean OpenGl_ShaderProgram::Initialize (const Handle(OpenGl_Context)&     theCtx,
132                                                    const Graphic3d_ShaderObjectList& theShaders)
133 {
134   if (theCtx.IsNull() || !Create (theCtx))
135   {
136     return Standard_False;
137   }
138
139   OSD_File aDeclFile     (Graphic3d_ShaderProgram::ShadersFolder() + "/Declarations.glsl");
140   OSD_File aDeclImplFile (Graphic3d_ShaderProgram::ShadersFolder() + "/DeclarationsImpl.glsl");
141   if (!aDeclFile.Exists()
142    || !aDeclImplFile.Exists())
143   {
144     const TCollection_ExtendedString aMsg = "Error! Failed to load OCCT shader declarations file";
145     theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB,
146                          GL_DEBUG_TYPE_ERROR_ARB,
147                          0,
148                          GL_DEBUG_SEVERITY_HIGH_ARB,
149                          aMsg);
150     return Standard_False;
151   }
152
153   TCollection_AsciiString aDeclarations;
154   aDeclFile.Open (OSD_ReadOnly, OSD_Protection());
155   aDeclFile.Read (aDeclarations, (int)aDeclFile.Size());
156   aDeclFile.Close();
157
158   TCollection_AsciiString aDeclImpl;
159   aDeclImplFile.Open (OSD_ReadOnly, OSD_Protection());
160   aDeclImplFile.Read (aDeclImpl, (int)aDeclImplFile.Size());
161   aDeclImplFile.Close();
162   aDeclarations += aDeclImpl;
163
164   for (Graphic3d_ShaderObjectList::Iterator anIter (theShaders);
165        anIter.More(); anIter.Next())
166   {
167     if (!anIter.Value()->IsDone())
168     {
169       const TCollection_ExtendedString aMsg = "Error! Failed to get shader source";
170       theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB,
171                            GL_DEBUG_TYPE_ERROR_ARB,
172                            0,
173                            GL_DEBUG_SEVERITY_HIGH_ARB,
174                            aMsg);
175       return Standard_False;
176     }
177
178     Handle(OpenGl_ShaderObject) aShader;
179
180     // Note: Add support of other shader types here
181     switch (anIter.Value()->Type())
182     {
183       case Graphic3d_TOS_VERTEX:
184         aShader = new OpenGl_ShaderObject (GL_VERTEX_SHADER);
185         break;
186       case Graphic3d_TOS_FRAGMENT:
187         aShader = new OpenGl_ShaderObject (GL_FRAGMENT_SHADER);
188         break;
189     }
190
191     // Is unsupported shader type?
192     if (aShader.IsNull())
193     {
194       TCollection_ExtendedString aMsg = "Error! Unsupported shader type";
195       theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB,
196                            GL_DEBUG_TYPE_ERROR_ARB,
197                            0,
198                            GL_DEBUG_SEVERITY_HIGH_ARB,
199                            aMsg);
200       return Standard_False;
201     }
202
203     if (!aShader->Create (theCtx))
204     {
205       aShader->Release (theCtx.operator->());
206       return Standard_False;
207     }
208
209     TCollection_AsciiString aSource = aDeclarations + anIter.Value()->Source();
210     if (anIter.Value()->Type() == Graphic3d_TOS_VERTEX)
211     {
212       aSource = TCollection_AsciiString ("#define VERTEX_SHADER\n") + aSource;
213     }
214
215     if (!aShader->LoadSource (theCtx, aSource))
216     {
217       const TCollection_ExtendedString aMsg = "Error! Failed to set shader source";
218       theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB,
219                            GL_DEBUG_TYPE_ERROR_ARB,
220                            0,
221                            GL_DEBUG_SEVERITY_HIGH_ARB,
222                            aMsg);
223       aShader->Release (theCtx.operator->());
224       return Standard_False;
225     }
226
227     if (!aShader->Compile (theCtx))
228     {
229       TCollection_AsciiString aLog;
230       aShader->FetchInfoLog (theCtx, aLog);
231       if (aLog.IsEmpty())
232       {
233         aLog = "Compilation log is empty.";
234       }
235       theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB,
236                            GL_DEBUG_TYPE_ERROR_ARB,
237                            0,
238                            GL_DEBUG_SEVERITY_HIGH_ARB,
239                            TCollection_ExtendedString ("Failed to compile shader object. Compilation log:\n") + aLog);
240       aShader->Release (theCtx.operator->());
241       return Standard_False;
242     }
243     else if (theCtx->caps->glslWarnings)
244     {
245       TCollection_AsciiString aLog;
246       aShader->FetchInfoLog (theCtx, aLog);
247       if (!aLog.IsEmpty()
248        && !aLog.IsEqual ("No errors.\n"))
249       {
250         theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB,
251                              GL_DEBUG_TYPE_PORTABILITY_ARB,
252                              0,
253                              GL_DEBUG_SEVERITY_LOW_ARB,
254                              TCollection_ExtendedString ("Shader compilation log:\n") + aLog);
255       }
256     }
257
258     if (!AttachShader (theCtx, aShader))
259     {
260       aShader->Release (theCtx.operator->());
261       return Standard_False;
262     }
263   }
264
265   if (!Link (theCtx))
266   {
267     TCollection_AsciiString aLog;
268     FetchInfoLog (theCtx, aLog);
269     if (aLog.IsEmpty())
270     {
271       aLog = "Linker log is empty.";
272     }
273     theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB,
274                          GL_DEBUG_TYPE_ERROR_ARB,
275                          0,
276                          GL_DEBUG_SEVERITY_HIGH_ARB,
277                          TCollection_ExtendedString ("Failed to link program object! Linker log:\n") + aLog);
278     return Standard_False;
279   }
280   else if (theCtx->caps->glslWarnings)
281   {
282     TCollection_AsciiString aLog;
283     FetchInfoLog (theCtx, aLog);
284     if (!aLog.IsEmpty()
285      && !aLog.IsEqual ("No errors.\n"))
286     {
287       theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION_ARB,
288                            GL_DEBUG_TYPE_PORTABILITY_ARB,
289                            0,
290                            GL_DEBUG_SEVERITY_LOW_ARB,
291                            TCollection_ExtendedString ("GLSL linker log:\n") + aLog);
292     }
293   }
294
295   return Standard_True;
296 }
297
298 // =======================================================================
299 // function : ~OpenGl_ShaderProgram
300 // purpose  : Releases resources of shader program
301 // =======================================================================
302 OpenGl_ShaderProgram::~OpenGl_ShaderProgram()
303 {
304   Release (NULL);
305 }
306
307 // =======================================================================
308 // function : AttachShader
309 // purpose  : Attaches shader object to the program object
310 // =======================================================================
311 Standard_Boolean OpenGl_ShaderProgram::AttachShader (const Handle(OpenGl_Context)&      theCtx,
312                                                      const Handle(OpenGl_ShaderObject)& theShader)
313 {
314   if (myProgramID == NO_PROGRAM || theShader.IsNull())
315   {
316     return Standard_False;
317   }
318
319   for (OpenGl_ShaderList::Iterator anIter (myShaderObjects); anIter.More(); anIter.Next())
320   {
321     if (theShader == anIter.Value())
322     {
323       return Standard_False;
324     }
325   }
326
327   myShaderObjects.Append (theShader);
328   theCtx->core20->glAttachShader (myProgramID, theShader->myShaderID);
329   return Standard_True;
330 }
331
332 // =======================================================================
333 // function : DetachShader
334 // purpose  : Detaches shader object to the program object
335 // =======================================================================
336 Standard_Boolean OpenGl_ShaderProgram::DetachShader (const Handle(OpenGl_Context)&      theCtx,
337                                                      const Handle(OpenGl_ShaderObject)& theShader)
338 {
339   if (myProgramID == NO_PROGRAM
340    || theShader.IsNull())
341   {
342     return Standard_False;
343   }
344
345   OpenGl_ShaderList::Iterator anIter (myShaderObjects);
346   while (anIter.More())
347   {
348     if (theShader == anIter.Value())
349     {
350       myShaderObjects.Remove (anIter);
351       break;
352     }
353
354     anIter.Next();
355   }
356
357   if (!anIter.More())
358   {
359     return Standard_False;
360   }
361
362   theCtx->core20->glDetachShader (myProgramID, theShader->myShaderID);
363   return Standard_True;
364 }
365
366 // =======================================================================
367 // function : Link
368 // purpose  : Links the program object
369 // =======================================================================
370 Standard_Boolean OpenGl_ShaderProgram::Link (const Handle(OpenGl_Context)& theCtx)
371 {
372   if (myProgramID == NO_PROGRAM)
373   {
374     return Standard_False;
375   }
376
377   GLint aStatus = GL_FALSE;
378   theCtx->core20->glLinkProgram (myProgramID);
379   theCtx->core20->glGetProgramiv (myProgramID, GL_LINK_STATUS, &aStatus);
380   if (aStatus == GL_FALSE)
381   {
382     return Standard_False;
383   }
384
385   for (GLint aVar = 0; aVar < OpenGl_OCCT_NUMBER_OF_STATE_VARIABLES; ++aVar)
386   {
387     myStateLocations[aVar] = GetUniformLocation (theCtx, PredefinedKeywords[aVar]);
388   }
389   return Standard_True;
390 }
391
392 // =======================================================================
393 // function : FetchInfoLog
394 // purpose  : Fetches information log of the last link operation
395 // =======================================================================
396 Standard_Boolean OpenGl_ShaderProgram::FetchInfoLog (const Handle(OpenGl_Context)& theCtx,
397                                                      TCollection_AsciiString&      theOutput)
398 {
399   if (myProgramID == NO_PROGRAM)
400   {
401     return Standard_False;
402   }
403
404   GLint aLength = 0;
405   theCtx->core20->glGetProgramiv (myProgramID, GL_INFO_LOG_LENGTH, &aLength);
406   if (aLength > 0)
407   {
408     GLchar* aLog = (GLchar*) alloca (aLength);
409     memset (aLog, 0, aLength);
410     theCtx->core20->glGetProgramInfoLog (myProgramID, aLength, NULL, aLog);
411     theOutput = aLog;
412   }
413   return Standard_True;
414 }
415
416 // =======================================================================
417 // function : Bind
418 // purpose  : Sets the program object as part of current rendering state
419 // =======================================================================
420 void OpenGl_ShaderProgram::Bind (const Handle(OpenGl_Context)& theCtx) const
421 {
422   if (myProgramID == NO_PROGRAM)
423   {
424     return;
425   }
426
427   theCtx->core20->glUseProgram (myProgramID);
428   theCtx->ShaderManager()->myIsPP = Standard_True;
429 }
430
431 // =======================================================================
432 // function : ApplyVariables
433 // purpose  : Fetches uniform variables from proxy shader program
434 // =======================================================================
435 Standard_Boolean OpenGl_ShaderProgram::ApplyVariables(const Handle(OpenGl_Context)& theCtx)
436 {
437   if (myProxy.IsNull() || myProxy->Variables().IsEmpty())
438   {
439     return Standard_False;
440   }
441
442   for (Graphic3d_ShaderVariableList::Iterator anIter (myProxy->Variables()); anIter.More(); anIter.Next())
443   {
444     mySetterSelector.Set (theCtx, anIter.Value(), this);
445   }
446
447   myProxy->ClearVariables();
448   return Standard_True;
449 }
450
451 // =======================================================================
452 // function : BindWithVariables
453 // purpose  : Binds the program object and applies variables
454 // =======================================================================
455 Standard_Boolean OpenGl_ShaderProgram::BindWithVariables (const Handle(OpenGl_Context)& theCtx)
456 {
457   Bind (theCtx);
458   return ApplyVariables (theCtx);
459 }
460
461 // =======================================================================
462 // function : Unbind
463 // purpose  : Reverts to fixed-function graphics pipeline (FFP)
464 // =======================================================================
465 void OpenGl_ShaderProgram::Unbind (const Handle(OpenGl_Context)& theCtx)
466 {
467   if (theCtx->ShaderManager()->myIsPP)
468   {
469     theCtx->core20->glUseProgram (NO_PROGRAM);
470     theCtx->ShaderManager()->myIsPP = Standard_False;
471   }
472 }
473
474 // =======================================================================
475 // function : ActiveState
476 // purpose  : Returns index of last modification for specified state type
477 // =======================================================================
478 Standard_Size OpenGl_ShaderProgram::ActiveState (const OpenGl_UniformStateType theType) const
479 {
480   if (theType < MaxStateTypes)
481   {
482     return myCurrentState[theType];
483   }
484   return 0;
485 }
486
487 // =======================================================================
488 // function : UpdateState
489 // purpose  : Updates index of last modification for specified state type
490 // =======================================================================
491 void OpenGl_ShaderProgram::UpdateState (const OpenGl_UniformStateType theType,
492                                         const Standard_Size           theIndex)
493 {
494   if (theType < MaxStateTypes)
495   {
496     myCurrentState[theType] = theIndex;
497   }
498 }
499
500 // =======================================================================
501 // function : GetUniformLocation
502 // purpose  : Returns location (index) of the specific uniform variable
503 // =======================================================================
504 GLint OpenGl_ShaderProgram::GetUniformLocation (const Handle(OpenGl_Context)& theCtx,
505                                                 const GLchar*                 theName) const
506 {
507   return myProgramID != NO_PROGRAM
508        ? theCtx->core20->glGetUniformLocation (myProgramID, theName)
509        : INVALID_LOCATION;
510 }
511
512 // =======================================================================
513 // function : GetAttributeLocation
514 // purpose  : Returns location (index) of the generic vertex attribute
515 // =======================================================================
516 GLint OpenGl_ShaderProgram::GetAttributeLocation (const Handle(OpenGl_Context)& theCtx,
517                                                   const GLchar*                 theName) const
518 {
519   return myProgramID != NO_PROGRAM
520        ? theCtx->core20->glGetAttribLocation (myProgramID, theName)
521        : INVALID_LOCATION;
522 }
523
524 // =======================================================================
525 // function : GetStateLocation
526 // purpose  : Returns location of the OCCT state uniform variable
527 // =======================================================================
528 GLint OpenGl_ShaderProgram::GetStateLocation (const GLuint theVariable) const
529 {
530   if (theVariable < OpenGl_OCCT_NUMBER_OF_STATE_VARIABLES)
531   {
532     return myStateLocations[theVariable];
533   }
534   return INVALID_LOCATION;
535 }
536
537 // =======================================================================
538 // function : GetUniform
539 // purpose  : Returns the value of the integer uniform variable
540 // =======================================================================
541 Standard_Boolean OpenGl_ShaderProgram::GetUniform (const Handle(OpenGl_Context)& theCtx,
542                                                    const GLchar*                 theName,
543                                                    OpenGl_Vec4i&                 theValue) const
544 {
545   return GetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue);
546 }
547
548 // =======================================================================
549 // function : GetUniform
550 // purpose  : Returns the value of the integer uniform variable
551 // =======================================================================
552 Standard_Boolean OpenGl_ShaderProgram::GetUniform (const Handle(OpenGl_Context)& theCtx,
553                                                    GLint                         theLocation,
554                                                    OpenGl_Vec4i&                 theValue) const
555 {
556   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
557   {
558     return Standard_False;
559   }
560
561   theCtx->core20->glGetUniformiv (myProgramID, theLocation, theValue);
562   return Standard_True;
563 }
564
565 // =======================================================================
566 // function : GetUniform
567 // purpose  : Returns the value of the floating-point uniform variable
568 // =======================================================================
569 Standard_Boolean OpenGl_ShaderProgram::GetUniform (const Handle(OpenGl_Context)& theCtx,
570                                                    const GLchar*                 theName,
571                                                    OpenGl_Vec4&                  theValue) const
572 {
573   return GetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue);
574 }
575
576 // =======================================================================
577 // function : GetUniform
578 // purpose  : Returns the value of the floating-point uniform variable
579 // =======================================================================
580 Standard_Boolean OpenGl_ShaderProgram::GetUniform (const Handle(OpenGl_Context)& theCtx,
581                                                    GLint                         theLocation,
582                                                    OpenGl_Vec4&                  theValue) const
583 {
584   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
585   {
586     return Standard_False;
587   }
588
589   theCtx->core20->glGetUniformfv (myProgramID, theLocation, theValue);
590   return Standard_True;
591 }
592
593 // =======================================================================
594 // function : GetAttribute
595 // purpose  : Returns the integer vertex attribute
596 // =======================================================================
597 Standard_Boolean OpenGl_ShaderProgram::GetAttribute (const Handle(OpenGl_Context)& theCtx,
598                                                      const GLchar*                 theName,
599                                                      OpenGl_Vec4i&                 theValue) const
600 {
601   return GetAttribute (theCtx, GetAttributeLocation (theCtx, theName), theValue);
602 }
603
604 // =======================================================================
605 // function : GetAttribute
606 // purpose  : Returns the integer vertex attribute
607 // =======================================================================
608 Standard_Boolean OpenGl_ShaderProgram::GetAttribute (const Handle(OpenGl_Context)& theCtx,
609                                                      GLint                         theIndex,
610                                                      OpenGl_Vec4i&                 theValue) const
611 {
612   if (myProgramID == NO_PROGRAM || theIndex == INVALID_LOCATION)
613   {
614     return Standard_False;
615   }
616
617   theCtx->core20->glGetVertexAttribiv (theIndex, GL_CURRENT_VERTEX_ATTRIB, theValue);
618   return Standard_True;
619 }
620
621 // =======================================================================
622 // function : GetAttribute
623 // purpose  : Returns the floating-point vertex attribute
624 // =======================================================================
625 Standard_Boolean OpenGl_ShaderProgram::GetAttribute (const Handle(OpenGl_Context)& theCtx,
626                                                      const GLchar*                 theName,
627                                                      OpenGl_Vec4&                  theValue) const
628 {
629   return GetAttribute (theCtx, GetAttributeLocation (theCtx, theName), theValue);
630 }
631
632 // =======================================================================
633 // function : GetAttribute
634 // purpose  : Returns the floating-point vertex attribute
635 // =======================================================================
636 Standard_Boolean OpenGl_ShaderProgram::GetAttribute (const Handle(OpenGl_Context)& theCtx,
637                                                      GLint                         theIndex,
638                                                      OpenGl_Vec4&                  theValue) const
639 {
640   if (myProgramID == NO_PROGRAM || theIndex == INVALID_LOCATION)
641   {
642     return Standard_False;
643   }
644
645   theCtx->core20->glGetVertexAttribfv (theIndex, GL_CURRENT_VERTEX_ATTRIB, theValue);
646   return Standard_True;
647 }
648
649 // =======================================================================
650 // function : SetAttributeName
651 // purpose  :
652 // =======================================================================
653 Standard_Boolean OpenGl_ShaderProgram::SetAttributeName (const Handle(OpenGl_Context)& theCtx,
654                                                          GLint                         theIndex,
655                                                          const GLchar*                 theName)
656 {
657   theCtx->core20fwd->glBindAttribLocation (myProgramID, theIndex, theName);
658   return Standard_True;
659 }
660   
661 // =======================================================================
662 // function : SetAttribute
663 // purpose  :
664 // =======================================================================
665 Standard_Boolean OpenGl_ShaderProgram::SetAttribute (const Handle(OpenGl_Context)& theCtx,
666                                                      const GLchar*                 theName,
667                                                      GLfloat                       theValue)
668 {
669   return SetAttribute (theCtx, GetAttributeLocation (theCtx, theName), theValue);
670 }
671
672 // =======================================================================
673 // function : SetAttribute
674 // purpose  :
675 // =======================================================================
676 Standard_Boolean OpenGl_ShaderProgram::SetAttribute (const Handle(OpenGl_Context)& theCtx,
677                                                      GLint                         theIndex,
678                                                      GLfloat                       theValue)
679 {
680   if (myProgramID == NO_PROGRAM || theIndex == INVALID_LOCATION)
681   {
682     return Standard_False;
683   }
684
685   theCtx->core20fwd->glVertexAttrib1f (theIndex, theValue);
686   return Standard_True;
687 }
688
689 // =======================================================================
690 // function : SetAttribute
691 // purpose  :
692 // =======================================================================
693 Standard_Boolean OpenGl_ShaderProgram::SetAttribute (const Handle(OpenGl_Context)& theCtx,
694                                                      const GLchar*                 theName,
695                                                      const OpenGl_Vec2&            theValue)
696 {
697   return SetAttribute (theCtx, GetAttributeLocation (theCtx, theName), theValue);
698 }
699
700 // =======================================================================
701 // function : SetAttribute
702 // purpose  :
703 // =======================================================================
704 Standard_Boolean OpenGl_ShaderProgram::SetAttribute (const Handle(OpenGl_Context)& theCtx,
705                                                      GLint                         theIndex,
706                                                      const OpenGl_Vec2&            theValue)
707 {
708   if (myProgramID == NO_PROGRAM || theIndex == INVALID_LOCATION)
709   {
710     return Standard_False;
711   }
712
713   theCtx->core20fwd->glVertexAttrib2fv (theIndex, theValue);
714   return Standard_True;
715 }
716
717 // =======================================================================
718 // function : SetAttribute
719 // purpose  :
720 // =======================================================================
721 Standard_Boolean OpenGl_ShaderProgram::SetAttribute (const Handle(OpenGl_Context)& theCtx,
722                                                      const GLchar*                 theName,
723                                                      const OpenGl_Vec3&            theValue)
724 {
725   return SetAttribute (theCtx, GetAttributeLocation (theCtx, theName), theValue);
726 }
727
728 // =======================================================================
729 // function : SetAttribute
730 // purpose  :
731 // =======================================================================
732 Standard_Boolean OpenGl_ShaderProgram::SetAttribute (const Handle(OpenGl_Context)& theCtx,
733                                                      GLint                         theIndex,
734                                                      const OpenGl_Vec3&            theValue)
735 {
736   if (myProgramID == NO_PROGRAM || theIndex == INVALID_LOCATION)
737   {
738     return Standard_False;
739   }
740
741   theCtx->core20fwd->glVertexAttrib3fv (theIndex, theValue);
742   return Standard_True;
743 }
744
745 // =======================================================================
746 // function : SetAttribute
747 // purpose  :
748 // =======================================================================
749 Standard_Boolean OpenGl_ShaderProgram::SetAttribute (const Handle(OpenGl_Context)& theCtx,
750                                                      const GLchar*                 theName,
751                                                      const OpenGl_Vec4&            theValue)
752 {
753   return SetAttribute (theCtx, GetAttributeLocation (theCtx, theName), theValue);
754 }
755
756 // =======================================================================
757 // function : SetAttribute
758 // purpose  :
759 // =======================================================================
760 Standard_Boolean OpenGl_ShaderProgram::SetAttribute (const Handle(OpenGl_Context)& theCtx,
761                                                      GLint                         theIndex,
762                                                      const OpenGl_Vec4&            theValue)
763 {
764   if (myProgramID == NO_PROGRAM || theIndex == INVALID_LOCATION)
765   {
766     return Standard_False;
767   }
768
769   theCtx->core20fwd->glVertexAttrib4fv (theIndex, theValue);
770   return Standard_True;
771 }
772
773 // =======================================================================
774 // function : SetUniform
775 // purpose  : Specifies the value of the integer uniform variable
776 // =======================================================================
777 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
778                                                    const GLchar*                 theName,
779                                                    GLint                         theValue)
780 {
781   return SetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue);
782 }
783
784 // =======================================================================
785 // function : SetUniform
786 // purpose  : Specifies the value of the integer uniform variable
787 // =======================================================================
788 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
789                                                    GLint                         theLocation,
790                                                    GLint                         theValue)
791 {
792   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
793   {
794     return Standard_False;
795   }
796
797   theCtx->core20->glUniform1i (theLocation, theValue);
798   return Standard_True;
799 }
800
801 // =======================================================================
802 // function : SetUniform
803 // purpose  : Specifies the value of the floating-point uniform variable
804 // =======================================================================
805 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
806                                                    const GLchar*                 theName,
807                                                    GLfloat                       theValue)
808 {
809   return SetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue);
810 }
811
812 // =======================================================================
813 // function : SetUniform
814 // purpose  : Specifies the value of the floating-point uniform variable
815 // =======================================================================
816 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
817                                                    GLint                         theLocation,
818                                                    GLfloat                       theValue)
819 {
820   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
821   {
822     return Standard_False;
823   }
824
825   theCtx->core20->glUniform1f (theLocation, theValue);
826   return Standard_True;
827 }
828
829 // =======================================================================
830 // function : SetUniform
831 // purpose  : Specifies the value of the integer uniform 2D vector
832 // =======================================================================
833 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
834                                                    const GLchar*                 theName,
835                                                    const OpenGl_Vec2i&           theValue)
836 {
837   return SetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue);
838 }
839
840 // =======================================================================
841 // function : SetUniform
842 // purpose  : Specifies the value of the integer uniform 2D vector
843 // =======================================================================
844 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
845                                                    GLint                         theLocation,
846                                                    const OpenGl_Vec2i&           theValue)
847 {
848   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
849   {
850     return Standard_False;
851   }
852
853   theCtx->core20->glUniform2iv (theLocation, 1, theValue);
854   return Standard_True;
855 }
856
857 // =======================================================================
858 // function : SetUniform
859 // purpose  : Specifies the value of the integer uniform 3D vector
860 // =======================================================================
861 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
862                                                    const GLchar*                 theName,
863                                                    const OpenGl_Vec3i&           theValue)
864 {
865   return SetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue);
866 }
867
868 // =======================================================================
869 // function : SetUniform
870 // purpose  : Specifies the value of the integer uniform 3D vector
871 // =======================================================================
872 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
873                                                    GLint                         theLocation,
874                                                    const OpenGl_Vec3i&           theValue)
875 {
876   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
877   {
878     return Standard_False;
879   }
880
881   theCtx->core20->glUniform3iv (theLocation, 1, theValue);
882   return Standard_True;
883 }
884
885 // =======================================================================
886 // function : SetUniform
887 // purpose  : Specifies the value of the integer uniform 4D vector
888 // =======================================================================
889 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
890                                                    const GLchar*                 theName,
891                                                    const OpenGl_Vec4i&           theValue)
892 {
893   return SetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue);
894 }
895
896 // =======================================================================
897 // function : SetUniform
898 // purpose  : Specifies the value of the integer uniform 4D vector
899 // =======================================================================
900 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
901                                                    GLint                         theLocation,
902                                                    const OpenGl_Vec4i&           theValue)
903 {
904   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
905   {
906     return Standard_False;
907   }
908
909   theCtx->core20->glUniform4iv (theLocation, 1, theValue);
910   return Standard_True;
911 }
912
913 // =======================================================================
914 // function : SetUniform
915 // purpose  : Specifies the value of the floating-point uniform 2D vector
916 // =======================================================================
917 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
918                                                    const GLchar*                 theName,
919                                                    const OpenGl_Vec2&            theValue)
920 {
921   return SetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue);
922 }
923
924 // =======================================================================
925 // function : SetUniform
926 // purpose  : Specifies the value of the floating-point uniform 2D vector
927 // =======================================================================
928 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
929                                                    GLint                         theLocation,
930                                                    const OpenGl_Vec2&            theValue)
931 {
932   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
933   {
934     return Standard_False;
935   }
936
937   theCtx->core20->glUniform2fv (theLocation, 1, theValue);
938   return Standard_True;
939 }
940
941 // =======================================================================
942 // function : SetUniform
943 // purpose  : Specifies the value of the floating-point uniform 3D vector
944 // =======================================================================
945 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
946                                                    const GLchar*                 theName,
947                                                    const OpenGl_Vec3&            theValue)
948 {
949   return SetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue);
950 }
951
952 // =======================================================================
953 // function : SetUniform
954 // purpose  : Specifies the value of the floating-point uniform 3D vector
955 // =======================================================================
956 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
957                                                    GLint                         theLocation,
958                                                    const OpenGl_Vec3&            theValue)
959 {
960   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
961   {
962     return Standard_False;
963   }
964
965   theCtx->core20->glUniform3fv (theLocation, 1, theValue);
966   return Standard_True;
967 }
968
969 // =======================================================================
970 // function : SetUniform
971 // purpose  : Specifies the value of the floating-point uniform 4D vector
972 // =======================================================================
973 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
974                                                    const GLchar*                 theName,
975                                                    const OpenGl_Vec4&            theValue)
976 {
977   return SetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue);
978 }
979
980 // =======================================================================
981 // function : SetUniform
982 // purpose  : Specifies the value of the floating-point uniform 4D vector
983 // =======================================================================
984 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
985                                                    GLint                         theLocation,
986                                                    const OpenGl_Vec4&            theValue)
987 {
988   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
989   {
990     return Standard_False;
991   }
992
993   theCtx->core20->glUniform4fv (theLocation, 1, theValue);
994   return Standard_True;
995 }
996
997 // =======================================================================
998 // function : SetUniform
999 // purpose  : Specifies the value of the floating-point uniform 4x4 matrix
1000 // =======================================================================
1001 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1002                                                    const GLchar*                 theName,
1003                                                    const OpenGl_Matrix&          theValue,
1004                                                    GLboolean                     theTranspose)
1005 {
1006   return SetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue, theTranspose);
1007 }
1008
1009 // =======================================================================
1010 // function : SetUniform
1011 // purpose  : Specifies the value of the floating-point uniform 4x4 matrix
1012 // =======================================================================
1013 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1014                                                    GLint                         theLocation,
1015                                                    const OpenGl_Matrix&          theValue,
1016                                                    GLboolean                     theTranspose)
1017 {
1018   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1019   {
1020     return Standard_False;
1021   }
1022
1023   theCtx->core20->glUniformMatrix4fv (theLocation, 1, theTranspose, *theValue.mat);
1024   return Standard_True;
1025 }
1026
1027 // =======================================================================
1028 // function : SetUniform
1029 // purpose  : Specifies the value of the floating-point uniform 4x4 matrix
1030 // =======================================================================
1031 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1032                                                    const GLchar*                 theName,
1033                                                    const Tmatrix3&               theValue,
1034                                                    GLboolean                     theTranspose)
1035 {
1036   return SetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue, theTranspose);
1037 }
1038
1039 // =======================================================================
1040 // function : SetUniform
1041 // purpose  : Specifies the value of the floating-point uniform 4x4 matrix
1042 // =======================================================================
1043 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1044                                                    GLint                         theLocation,
1045                                                    const Tmatrix3&               theValue,
1046                                                    GLboolean                     theTranspose)
1047 {
1048   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1049   {
1050     return Standard_False;
1051   }
1052
1053   theCtx->core20->glUniformMatrix4fv (theLocation, 1, theTranspose, *theValue);
1054   return Standard_True;
1055 }
1056
1057 // =======================================================================
1058 // function : SetUniform
1059 // purpose  : Specifies the value of the float uniform array
1060 // =======================================================================
1061 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1062                                                    GLint                         theLocation,
1063                                                    GLuint                        theCount,
1064                                                    const Standard_ShortReal*     theData)
1065 {
1066   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1067   {
1068     return Standard_False;
1069   }
1070
1071   theCtx->core20->glUniform1fv (theLocation, theCount, theData);
1072   return Standard_True;
1073 }
1074
1075 // =======================================================================
1076 // function : SetUniform
1077 // purpose  : Specifies the value of the float2 uniform array
1078 // =======================================================================
1079 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1080                                                    GLint                         theLocation,
1081                                                    GLuint                        theCount,
1082                                                    const OpenGl_Vec2*            theData)
1083 {
1084   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1085   {
1086     return Standard_False;
1087   }
1088
1089   theCtx->core20->glUniform2fv (theLocation, theCount, theData[0].GetData());
1090   return Standard_True;
1091 }
1092
1093 // =======================================================================
1094 // function : SetUniform
1095 // purpose  : Specifies the value of the float3 uniform array
1096 // =======================================================================
1097 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1098                                                    GLint                         theLocation,
1099                                                    GLuint                        theCount,
1100                                                    const OpenGl_Vec3*            theData)
1101 {
1102   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1103   {
1104     return Standard_False;
1105   }
1106
1107   theCtx->core20->glUniform3fv (theLocation, theCount, theData[0].GetData());
1108   return Standard_True;
1109 }
1110
1111 // =======================================================================
1112 // function : SetUniform
1113 // purpose  : Specifies the value of the float4 uniform array
1114 // =======================================================================
1115 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1116                                                    GLint                         theLocation,
1117                                                    GLuint                        theCount,
1118                                                    const OpenGl_Vec4*            theData)
1119 {
1120   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1121   {
1122     return Standard_False;
1123   }
1124
1125   theCtx->core20->glUniform4fv (theLocation, theCount, theData[0].GetData());
1126   return Standard_True;
1127 }
1128
1129 // =======================================================================
1130 // function : SetUniform
1131 // purpose  : Specifies the value of the integer uniform array
1132 // =======================================================================
1133 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1134                                                    GLint                         theLocation,
1135                                                    GLuint                        theCount,
1136                                                    const Standard_Integer*       theData)
1137 {
1138   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1139   {
1140     return Standard_False;
1141   }
1142
1143   theCtx->core20->glUniform1iv (theLocation, theCount, theData);
1144   return Standard_True;
1145 }
1146
1147 // =======================================================================
1148 // function : SetUniform
1149 // purpose  : Specifies the value of the int2 uniform array
1150 // =======================================================================
1151 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1152                                                    GLint                         theLocation,
1153                                                    GLuint                        theCount,
1154                                                    const OpenGl_Vec2i*           theData)
1155 {
1156   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1157   {
1158     return Standard_False;
1159   }
1160
1161   theCtx->core20->glUniform2iv (theLocation, theCount, theData[0].GetData());
1162   return Standard_True;
1163 }
1164
1165 // =======================================================================
1166 // function : SetUniform
1167 // purpose  : Specifies the value of the int3 uniform array
1168 // =======================================================================
1169 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1170                                                    GLint                         theLocation,
1171                                                    GLuint                        theCount,
1172                                                    const OpenGl_Vec3i*           theData)
1173 {
1174   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1175   {
1176     return Standard_False;
1177   }
1178
1179   theCtx->core20->glUniform3iv (theLocation, theCount, theData[0].GetData());
1180   return Standard_True;
1181 }
1182
1183 // =======================================================================
1184 // function : SetUniform
1185 // purpose  : Specifies the value of the int4 uniform array
1186 // =======================================================================
1187 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1188                                                    GLint                         theLocation,
1189                                                    GLuint                        theCount,
1190                                                    const OpenGl_Vec4i*           theData)
1191 {
1192   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1193   {
1194     return Standard_False;
1195   }
1196
1197   theCtx->core20->glUniform4iv (theLocation, theCount, theData[0].GetData());
1198   return Standard_True;
1199 }
1200
1201 // =======================================================================
1202 // function : SetSampler
1203 // purpose  : Specifies the value of the sampler uniform variable
1204 // =======================================================================
1205 Standard_Boolean OpenGl_ShaderProgram::SetSampler (const Handle(OpenGl_Context)& theCtx,
1206                                                    const GLchar*                 theName,
1207                                                    const GLenum                  theTextureUnit)
1208 {
1209   return SetSampler (theCtx, GetUniformLocation (theCtx, theName), theTextureUnit);
1210 }
1211
1212 // =======================================================================
1213 // function : SetSampler
1214 // purpose  : Specifies the value of the sampler uniform variable
1215 // =======================================================================
1216 Standard_Boolean OpenGl_ShaderProgram::SetSampler (const Handle(OpenGl_Context)& theCtx,
1217                                                    GLint                         theLocation,
1218                                                    const GLenum                  theTextureUnit)
1219 {
1220   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1221   {
1222     return Standard_False;
1223   }
1224
1225   theCtx->core20->glUniform1i (theLocation, theTextureUnit);
1226   return Standard_True;
1227 }
1228
1229 // =======================================================================
1230 // function : Create
1231 // purpose  : Creates new empty shader program of specified type
1232 // =======================================================================
1233 Standard_Boolean OpenGl_ShaderProgram::Create (const Handle(OpenGl_Context)& theCtx)
1234 {
1235   if (myProgramID == NO_PROGRAM
1236    && theCtx->core20 != NULL)
1237   {
1238     myProgramID = theCtx->core20->glCreateProgram();
1239   }
1240
1241   return myProgramID != NO_PROGRAM;
1242 }
1243
1244 // =======================================================================
1245 // function : Release
1246 // purpose  : Destroys shader program
1247 // =======================================================================
1248 void OpenGl_ShaderProgram::Release (const OpenGl_Context* theCtx)
1249 {
1250   if (myProgramID == NO_PROGRAM)
1251   {
1252     return;
1253   }
1254
1255   Standard_ASSERT_RETURN (theCtx != NULL,
1256     "OpenGl_ShaderProgram destroyed without GL context! Possible GPU memory leakage...",);
1257
1258   for (OpenGl_ShaderList::Iterator anIter (myShaderObjects); anIter.More(); anIter.Next())
1259   {
1260     if (!anIter.Value().IsNull())
1261     {
1262       anIter.ChangeValue()->Release (theCtx);
1263       anIter.ChangeValue().Nullify();
1264     }
1265   }
1266
1267   if (theCtx->core20 != NULL
1268    && theCtx->IsValid())
1269   {
1270     theCtx->core20->glDeleteProgram (myProgramID);
1271   }
1272
1273   myProgramID = NO_PROGRAM;
1274 }