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