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