0031583: Visualization, OpenGl_Context - load OpenGL ES 3.0 functions
[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_Environment.hxx>
18 #include <OSD_Protection.hxx>
19
20 #include <Graphic3d_Buffer.hxx>
21 #include <Standard_Assert.hxx>
22 #include <Standard_Atomic.hxx>
23 #include <TCollection_ExtendedString.hxx>
24
25 #include <OpenGl_Context.hxx>
26 #include <OpenGl_ShaderProgram.hxx>
27 #include <OpenGl_ShaderManager.hxx>
28 #include <OpenGl_ArbTexBindless.hxx>
29
30 #include <OpenGl_GlCore32.hxx>
31
32 #include "../Shaders/Shaders_DeclarationsImpl_glsl.pxx"
33 #include "../Shaders/Shaders_Declarations_glsl.pxx"
34
35 #ifdef _WIN32
36   #include <malloc.h> // for alloca()
37 #endif
38
39 IMPLEMENT_STANDARD_RTTIEXT(OpenGl_ShaderProgram, OpenGl_NamedResource)
40
41 OpenGl_VariableSetterSelector OpenGl_ShaderProgram::mySetterSelector = OpenGl_VariableSetterSelector();
42
43 // Declare OCCT-specific OpenGL/GLSL shader variables
44 Standard_CString OpenGl_ShaderProgram::PredefinedKeywords[] =
45 {
46   "occModelWorldMatrix",                 // OpenGl_OCC_MODEL_WORLD_MATRIX
47   "occWorldViewMatrix",                  // OpenGl_OCC_WORLD_VIEW_MATRIX
48   "occProjectionMatrix",                 // OpenGl_OCC_PROJECTION_MATRIX
49   "occModelWorldMatrixInverse",          // OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE
50   "occWorldViewMatrixInverse",           // OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE
51   "occProjectionMatrixInverse",          // OpenGl_OCC_PROJECTION_MATRIX_INVERSE
52   "occModelWorldMatrixTranspose",        // OpenGl_OCC_MODEL_WORLD_MATRIX_TRANSPOSE
53   "occWorldViewMatrixTranspose",         // OpenGl_OCC_WORLD_VIEW_MATRIX_TRANSPOSE
54   "occProjectionMatrixTranspose",        // OpenGl_OCC_PROJECTION_MATRIX_TRANSPOSE
55   "occModelWorldMatrixInverseTranspose", // OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE_TRANSPOSE
56   "occWorldViewMatrixInverseTranspose",  // OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE_TRANSPOSE
57   "occProjectionMatrixInverseTranspose", // OpenGl_OCC_PROJECTION_MATRIX_INVERSE_TRANSPOSE
58
59   "occClipPlaneEquations",  // OpenGl_OCC_CLIP_PLANE_EQUATIONS
60   "occClipPlaneChains",     // OpenGl_OCC_CLIP_PLANE_CHAINS
61   "occClipPlaneCount",      // OpenGl_OCC_CLIP_PLANE_COUNT
62
63   "occLightSourcesCount",   // OpenGl_OCC_LIGHT_SOURCE_COUNT
64   "occLightSourcesTypes",   // OpenGl_OCC_LIGHT_SOURCE_TYPES
65   "occLightSources",        // OpenGl_OCC_LIGHT_SOURCE_PARAMS
66   "occLightAmbient",        // OpenGl_OCC_LIGHT_AMBIENT
67
68   "occTextureEnable",       // OpenGl_OCCT_TEXTURE_ENABLE
69   "occDistinguishingMode",  // OpenGl_OCCT_DISTINGUISH_MODE
70   "occPbrFrontMaterial",    // OpenGl_OCCT_PBR_FRONT_MATERIAL
71   "occPbrBackMaterial",     // OpenGl_OCCT_PBR_BACK_MATERIAL
72   "occFrontMaterial",       // OpenGl_OCCT_COMMON_FRONT_MATERIAL
73   "occBackMaterial",        // OpenGl_OCCT_COMMON_BACK_MATERIAL
74   "occAlphaCutoff",         // OpenGl_OCCT_ALPHA_CUTOFF
75   "occColor",               // OpenGl_OCCT_COLOR
76
77   "occOitOutput",           // OpenGl_OCCT_OIT_OUTPUT
78   "occOitDepthFactor",      // OpenGl_OCCT_OIT_DEPTH_FACTOR
79
80   "occTexTrsf2d",           // OpenGl_OCCT_TEXTURE_TRSF2D
81   "occPointSize",           // OpenGl_OCCT_POINT_SIZE
82
83   "occViewport",            // OpenGl_OCCT_VIEWPORT
84   "occLineWidth",           // OpenGl_OCCT_LINE_WIDTH
85   "occLineFeather",         // OpenGl_OCCT_LINE_FEATHER
86   "occStipplePattern",      // OpenGl_OCCT_LINE_STIPPLE_PATTERN
87   "occStippleFactor",       // OpenGl_OCCT_LINE_STIPPLE_FACTOR
88   "occWireframeColor",      // OpenGl_OCCT_WIREFRAME_COLOR
89   "occIsQuadMode",          // OpenGl_OCCT_QUAD_MODE_STATE
90
91   "occOrthoScale",          // OpenGl_OCCT_ORTHO_SCALE
92   "occSilhouetteThickness", // OpenGl_OCCT_SILHOUETTE_THICKNESS
93
94   "occNbSpecIBLLevels"      // OpenGl_OCCT_NB_SPEC_IBL_LEVELS
95 };
96
97 namespace
98 {
99   //! Convert Graphic3d_TypeOfShaderObject enumeration into OpenGL enumeration.
100   static GLenum shaderTypeToGl (Graphic3d_TypeOfShaderObject theType)
101   {
102     switch (theType)
103     {
104       case Graphic3d_TOS_VERTEX:          return GL_VERTEX_SHADER;
105       case Graphic3d_TOS_FRAGMENT:        return GL_FRAGMENT_SHADER;
106       case Graphic3d_TOS_GEOMETRY:        return GL_GEOMETRY_SHADER;
107       case Graphic3d_TOS_TESS_CONTROL:    return GL_TESS_CONTROL_SHADER;
108       case Graphic3d_TOS_TESS_EVALUATION: return GL_TESS_EVALUATION_SHADER;
109       case Graphic3d_TOS_COMPUTE:         return GL_COMPUTE_SHADER;
110     }
111     return 0;
112   }
113 }
114
115 // =======================================================================
116 // function : OpenGl_VariableSetterSelector
117 // purpose  : Creates new variable setter selector
118 // =======================================================================
119 OpenGl_VariableSetterSelector::OpenGl_VariableSetterSelector()
120 {
121   // Note: Add new variable setters here
122   mySetterList = OpenGl_HashMapInitializer::CreateListOf<size_t, OpenGl_SetterInterface*>
123     (Graphic3d_UniformValueTypeID<int>::ID,          new OpenGl_VariableSetter<int>())
124     (Graphic3d_UniformValueTypeID<float>::ID,        new OpenGl_VariableSetter<float>())
125     (Graphic3d_UniformValueTypeID<OpenGl_Vec2>::ID,  new OpenGl_VariableSetter<OpenGl_Vec2>())
126     (Graphic3d_UniformValueTypeID<OpenGl_Vec3>::ID,  new OpenGl_VariableSetter<OpenGl_Vec3>())
127     (Graphic3d_UniformValueTypeID<OpenGl_Vec4>::ID,  new OpenGl_VariableSetter<OpenGl_Vec4>())
128     (Graphic3d_UniformValueTypeID<OpenGl_Vec2i>::ID, new OpenGl_VariableSetter<OpenGl_Vec2i>())
129     (Graphic3d_UniformValueTypeID<OpenGl_Vec3i>::ID, new OpenGl_VariableSetter<OpenGl_Vec3i>())
130     (Graphic3d_UniformValueTypeID<OpenGl_Vec4i>::ID, new OpenGl_VariableSetter<OpenGl_Vec4i>());
131 }
132
133 // =======================================================================
134 // function : ~OpenGl_VariableSetterSelector
135 // purpose  : Releases memory resources of variable setter selector
136 // =======================================================================
137 OpenGl_VariableSetterSelector::~OpenGl_VariableSetterSelector()
138 {
139   for (OpenGl_SetterList::Iterator anIt (mySetterList); anIt.More(); anIt.Next())
140   {
141     delete anIt.Value();
142   }
143
144   mySetterList.Clear();
145 }
146
147 // =======================================================================
148 // function : Set
149 // purpose  : Sets generic variable to specified shader program
150 // =======================================================================
151 void OpenGl_VariableSetterSelector::Set (const Handle(OpenGl_Context)&           theCtx,
152                                          const Handle(Graphic3d_ShaderVariable)& theVariable,
153                                          OpenGl_ShaderProgram*                   theProgram) const
154 {
155   Standard_ASSERT_RETURN (mySetterList.IsBound (theVariable->Value()->TypeID()),
156     "The type of user-defined uniform variable is not supported...", );
157
158   mySetterList.Find (theVariable->Value()->TypeID())->Set (theCtx, theVariable, theProgram);
159 }
160
161 // =======================================================================
162 // function : OpenGl_ShaderProgram
163 // purpose  : Creates uninitialized shader program
164 // =======================================================================
165 OpenGl_ShaderProgram::OpenGl_ShaderProgram (const Handle(Graphic3d_ShaderProgram)& theProxy,
166                                             const TCollection_AsciiString& theId)
167 : OpenGl_NamedResource (!theProxy.IsNull() ? theProxy->GetId() : theId),
168   myProgramID (NO_PROGRAM),
169   myProxy     (theProxy),
170   myShareCount(1),
171   myNbLightsMax (0),
172   myNbClipPlanesMax (0),
173   myNbFragOutputs (1),
174   myTextureSetBits (Graphic3d_TextureSetBits_NONE),
175   myHasAlphaTest (false),
176   myHasWeightOitOutput (false),
177   myHasTessShader (false)
178 {
179   memset (myCurrentState, 0, sizeof (myCurrentState));
180 }
181
182 // =======================================================================
183 // function : Initialize
184 // purpose  : Initializes program object with the list of shader objects
185 // =======================================================================
186 Standard_Boolean OpenGl_ShaderProgram::Initialize (const Handle(OpenGl_Context)&     theCtx,
187                                                    const Graphic3d_ShaderObjectList& theShaders)
188 {
189   myHasTessShader = false;
190   if (theCtx.IsNull() || !Create (theCtx))
191   {
192     return Standard_False;
193   }
194
195   TCollection_AsciiString aHeaderVer = !myProxy.IsNull() ? myProxy->Header() : TCollection_AsciiString();
196   int aShaderMask = 0;
197   for (Graphic3d_ShaderObjectList::Iterator anIter (theShaders); anIter.More(); anIter.Next())
198   {
199     aShaderMask |= anIter.Value()->Type();
200   }
201   myHasTessShader = (aShaderMask & (Graphic3d_TOS_TESS_CONTROL | Graphic3d_TOS_TESS_EVALUATION)) != 0;
202   myNbFragOutputs = !myProxy.IsNull() ? myProxy->NbFragmentOutputs() : 1;
203   myTextureSetBits = Graphic3d_TextureSetBits_NONE;
204   myHasAlphaTest  = !myProxy.IsNull() && myProxy->HasAlphaTest();
205   myHasWeightOitOutput = !myProxy.IsNull() ? myProxy->HasWeightOitOutput() && myNbFragOutputs >= 2 : 1;
206
207   // detect the minimum GLSL version required for defined Shader Objects
208 #if defined(GL_ES_VERSION_2_0)
209   if (myHasTessShader)
210   {
211     if (!theCtx->IsGlGreaterEqual (3, 2))
212     {
213       theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
214                            "Error! Tessellation shader requires OpenGL ES 3.2+");
215       return false;
216     }
217     else if (aHeaderVer.IsEmpty())
218     {
219       aHeaderVer = "#version 320 es";
220     }
221   }
222   else if ((aShaderMask & Graphic3d_TOS_GEOMETRY) != 0)
223   {
224     switch (theCtx->hasGeometryStage)
225     {
226       case OpenGl_FeatureNotAvailable:
227       {
228         theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
229                              "Error! Geometry shader requires OpenGL ES 3.2+ or GL_EXT_geometry_shader");
230         return false;
231       }
232       case OpenGl_FeatureInExtensions:
233       {
234         if (aHeaderVer.IsEmpty())
235         {
236           aHeaderVer = "#version 310 es";
237         }
238         break;
239       }
240       case OpenGl_FeatureInCore:
241       {
242         if (aHeaderVer.IsEmpty())
243         {
244           aHeaderVer = "#version 320 es";
245         }
246         break;
247       }
248     }
249   }
250   else if ((aShaderMask & Graphic3d_TOS_COMPUTE) != 0)
251   {
252     if (!theCtx->IsGlGreaterEqual (3, 1))
253     {
254       theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
255                            "Error! Compute shaders require OpenGL ES 3.1+");
256       return false;
257     }
258     else if (aHeaderVer.IsEmpty())
259     {
260       aHeaderVer = "#version 310 es";
261     }
262   }
263 #else
264   if ((aShaderMask & Graphic3d_TOS_COMPUTE) != 0)
265   {
266     if (!theCtx->IsGlGreaterEqual (4, 3))
267     {
268       theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
269                            "Error! Compute shaders require OpenGL 4.3+");
270       return 0;
271     }
272     else if (aHeaderVer.IsEmpty())
273     {
274       aHeaderVer = "#version 430";
275     }
276   }
277   else if (myHasTessShader)
278   {
279     if (!theCtx->IsGlGreaterEqual (4, 0))
280     {
281       theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
282                            "Error! Tessellation shaders require OpenGL 4.0+");
283       return 0;
284     }
285     else if (aHeaderVer.IsEmpty())
286     {
287       aHeaderVer = "#version 400";
288     }
289   }
290   else if ((aShaderMask & Graphic3d_TOS_GEOMETRY) != 0)
291   {
292     if (!theCtx->IsGlGreaterEqual (3, 2))
293     {
294       theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
295                            "Error! Geometry shaders require OpenGL 3.2+");
296       return 0;
297     }
298     else if (aHeaderVer.IsEmpty())
299     {
300       aHeaderVer = "#version 150";
301     }
302   }
303 #endif
304
305   for (Graphic3d_ShaderObjectList::Iterator anIter (theShaders); anIter.More(); anIter.Next())
306   {
307     if (!anIter.Value()->IsDone())
308     {
309       const TCollection_ExtendedString aMsg = "Error! Failed to get shader source";
310       theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH, aMsg);
311       return Standard_False;
312     }
313
314     const GLenum aShaderType = shaderTypeToGl (anIter.Value()->Type());
315     if (aShaderType == 0)
316     {
317       return Standard_False;
318     }
319
320     Handle(OpenGl_ShaderObject) aShader = new OpenGl_ShaderObject (aShaderType);
321     if (!aShader->Create (theCtx))
322     {
323       aShader->Release (theCtx.operator->());
324       return Standard_False;
325     }
326
327     TCollection_AsciiString anExtensions = "// Enable extensions used in OCCT GLSL programs\n";
328     if (myNbFragOutputs > 1)
329     {
330       if (theCtx->hasDrawBuffers)
331       {
332         anExtensions += "#define OCC_ENABLE_draw_buffers\n";
333         if (myHasWeightOitOutput)
334         {
335           anExtensions += "#define OCC_WRITE_WEIGHT_OIT_COVERAGE\n";
336         }
337       }
338       else
339       {
340         theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
341                              "Error! Multiple draw buffers required by the program, but aren't supported by OpenGL");
342         return Standard_False;
343       }
344
345       if (theCtx->hasDrawBuffers == OpenGl_FeatureInExtensions)
346       {
347         if (theCtx->arbDrawBuffers)
348         {
349           anExtensions += "#extension GL_ARB_draw_buffers : enable\n";
350         }
351         else if (theCtx->extDrawBuffers)
352         {
353           anExtensions += "#extension GL_EXT_draw_buffers : enable\n";
354         }
355       }
356     }
357     if (myHasAlphaTest)
358     {
359       anExtensions += "#define OCC_ALPHA_TEST\n";
360     }
361
362     if (theCtx->hasSampleVariables == OpenGl_FeatureInExtensions)
363     {
364 #if defined(GL_ES_VERSION_2_0)
365       if (theCtx->oesSampleVariables)
366       {
367         anExtensions += "#extension GL_OES_sample_variables : enable\n";
368       }
369 #else
370       if (theCtx->arbSampleShading)
371       {
372         anExtensions += "#extension GL_ARB_sample_shading : enable\n";
373       }
374 #endif
375     }
376 #if defined(GL_ES_VERSION_2_0)
377     if (theCtx->hasGeometryStage == OpenGl_FeatureInExtensions)
378     {
379       anExtensions += "#extension GL_EXT_geometry_shader : enable\n"
380                       "#extension GL_EXT_shader_io_blocks : enable\n";
381     }
382 #endif
383
384     TCollection_AsciiString aPrecisionHeader;
385     if (anIter.Value()->Type() == Graphic3d_TOS_FRAGMENT)
386     {
387     #if defined(GL_ES_VERSION_2_0)
388       aPrecisionHeader = theCtx->hasHighp
389                        ? "precision highp float;\n"
390                          "precision highp int;\n"
391                        : "precision mediump float;\n"
392                          "precision mediump int;\n";
393     #endif
394     }
395
396     TCollection_AsciiString aHeaderType;
397     switch (anIter.Value()->Type())
398     {
399       case Graphic3d_TOS_COMPUTE:         { aHeaderType = "#define COMPUTE_SHADER\n";         break; }
400       case Graphic3d_TOS_VERTEX:          { aHeaderType = "#define VERTEX_SHADER\n";          break; }
401       case Graphic3d_TOS_TESS_CONTROL:    { aHeaderType = "#define TESS_CONTROL_SHADER\n";    break; }
402       case Graphic3d_TOS_TESS_EVALUATION: { aHeaderType = "#define TESS_EVALUATION_SHADER\n"; break; }
403       case Graphic3d_TOS_GEOMETRY:        { aHeaderType = "#define GEOMETRY_SHADER\n";        break; }
404       case Graphic3d_TOS_FRAGMENT:        { aHeaderType = "#define FRAGMENT_SHADER\n";        break; }
405     }
406
407     TCollection_AsciiString aHeaderConstants;
408     myNbLightsMax     = !myProxy.IsNull() ? myProxy->NbLightsMax() : 0;
409     myNbClipPlanesMax = !myProxy.IsNull() ? myProxy->NbClipPlanesMax() : 0;
410     aHeaderConstants += TCollection_AsciiString("#define THE_MAX_LIGHTS ") + myNbLightsMax + "\n";
411     aHeaderConstants += TCollection_AsciiString("#define THE_MAX_CLIP_PLANES ") + myNbClipPlanesMax + "\n";
412     aHeaderConstants += TCollection_AsciiString("#define THE_NB_FRAG_OUTPUTS ") + myNbFragOutputs + "\n";
413     if (!myProxy.IsNull()
414       && myProxy->HasDefaultSampler())
415     {
416       aHeaderConstants += "#define THE_HAS_DEFAULT_SAMPLER\n";
417     }
418     if (!myProxy.IsNull())
419     {
420       if (myProxy->IsPBR())
421       {
422         aHeaderConstants += "#define THE_IS_PBR\n";
423       }
424       if ((myProxy->TextureSetBits() & Graphic3d_TextureSetBits_BaseColor) != 0)
425       {
426         aHeaderConstants += "#define THE_HAS_TEXTURE_COLOR\n";
427       }
428       if ((myProxy->TextureSetBits() & Graphic3d_TextureSetBits_Emissive) != 0)
429       {
430         aHeaderConstants += "#define THE_HAS_TEXTURE_EMISSIVE\n";
431       }
432       if ((myProxy->TextureSetBits() & Graphic3d_TextureSetBits_Normal) != 0)
433       {
434         aHeaderConstants += "#define THE_HAS_TEXTURE_NORMAL\n";
435       }
436       if ((myProxy->TextureSetBits() & Graphic3d_TextureSetBits_Occlusion) != 0)
437       {
438         aHeaderConstants += "#define THE_HAS_TEXTURE_OCCLUSION\n";
439       }
440       if ((myProxy->TextureSetBits() & Graphic3d_TextureSetBits_MetallicRoughness) != 0)
441       {
442         aHeaderConstants += "#define THE_HAS_TEXTURE_METALROUGHNESS\n";
443       }
444     }
445
446     const TCollection_AsciiString aSource = aHeaderVer                     // #version   - header defining GLSL version, should be first
447                                           + (!aHeaderVer.IsEmpty() ? "\n" : "")
448                                           + anExtensions                   // #extension - list of enabled extensions,   should be second
449                                           + aPrecisionHeader               // precision  - default precision qualifiers, should be before any code
450                                           + aHeaderType                    // auxiliary macros defining a shader stage (type)
451                                           + aHeaderConstants
452                                           + Shaders_Declarations_glsl      // common declarations (global constants and Vertex Shader inputs)
453                                           + Shaders_DeclarationsImpl_glsl
454                                           + anIter.Value()->Source();      // the source code itself (defining main() function)
455     if (!aShader->LoadAndCompile (theCtx, myResourceId, aSource))
456     {
457       aShader->Release (theCtx.operator->());
458       return Standard_False;
459     }
460
461     if (theCtx->caps->glslDumpLevel)
462     {
463       TCollection_AsciiString anOutputSource = aSource;
464       if (theCtx->caps->glslDumpLevel == OpenGl_ShaderProgramDumpLevel_Short)
465       {
466         anOutputSource = aHeaderVer
467                        + (!aHeaderVer.IsEmpty() ? "\n" : "")
468                        + anExtensions
469                        + aPrecisionHeader
470                        + aHeaderType
471                        + aHeaderConstants
472                        + anIter.Value()->Source();
473       }
474       aShader->DumpSourceCode (theCtx, myResourceId, anOutputSource);
475     }
476
477     if (!AttachShader (theCtx, aShader))
478     {
479       aShader->Release (theCtx.operator->());
480       return Standard_False;
481     }
482   }
483
484   // bind locations for pre-defined Vertex Attributes
485   SetAttributeName (theCtx, Graphic3d_TOA_POS,   "occVertex");
486   SetAttributeName (theCtx, Graphic3d_TOA_NORM,  "occNormal");
487   SetAttributeName (theCtx, Graphic3d_TOA_UV,    "occTexCoord");
488   SetAttributeName (theCtx, Graphic3d_TOA_COLOR, "occVertColor");
489
490   // bind custom Vertex Attributes
491   if (!myProxy.IsNull())
492   {
493     for (Graphic3d_ShaderAttributeList::Iterator anAttribIter (myProxy->VertexAttributes());
494          anAttribIter.More(); anAttribIter.Next())
495     {
496       SetAttributeName (theCtx, anAttribIter.Value()->Location(), anAttribIter.Value()->Name().ToCString());
497     }
498   }
499
500   if (!Link (theCtx))
501   {
502     return Standard_False;
503   }
504
505   // set uniform defaults
506   const Handle(OpenGl_ShaderProgram)& anOldProgram = theCtx->ActiveProgram();
507   theCtx->core20fwd->glUseProgram (myProgramID);
508   if (const OpenGl_ShaderUniformLocation aLocTexEnable = GetStateLocation (OpenGl_OCCT_TEXTURE_ENABLE))
509   {
510     SetUniform (theCtx, aLocTexEnable, 0); // Off
511   }
512   if (const OpenGl_ShaderUniformLocation aLocSampler = GetUniformLocation (theCtx, "occActiveSampler"))
513   {
514     SetUniform (theCtx, aLocSampler, GLint(Graphic3d_TextureUnit_0));
515   }
516   if (const OpenGl_ShaderUniformLocation aLocSampler = GetUniformLocation (theCtx, "occSamplerBaseColor"))
517   {
518     myTextureSetBits |= Graphic3d_TextureSetBits_BaseColor;
519     SetUniform (theCtx, aLocSampler, GLint(Graphic3d_TextureUnit_BaseColor));
520   }
521   if (const OpenGl_ShaderUniformLocation aLocSampler = GetUniformLocation (theCtx, "occSamplerPointSprite"))
522   {
523     // Graphic3d_TextureUnit_PointSprite
524     //myTextureSetBits |= Graphic3d_TextureSetBits_PointSprite;
525     SetUniform (theCtx, aLocSampler, GLint(theCtx->SpriteTextureUnit()));
526   }
527   if (const OpenGl_ShaderUniformLocation aLocSampler = GetUniformLocation (theCtx, "occSamplerMetallicRoughness"))
528   {
529     myTextureSetBits |= Graphic3d_TextureSetBits_MetallicRoughness;
530     SetUniform (theCtx, aLocSampler, GLint(Graphic3d_TextureUnit_MetallicRoughness));
531   }
532   if (const OpenGl_ShaderUniformLocation aLocSampler = GetUniformLocation (theCtx, "occSamplerEmissive"))
533   {
534     myTextureSetBits |= Graphic3d_TextureSetBits_Emissive;
535     SetUniform (theCtx, aLocSampler, GLint(Graphic3d_TextureUnit_Emissive));
536   }
537   if (const OpenGl_ShaderUniformLocation aLocSampler = GetUniformLocation (theCtx, "occSamplerOcclusion"))
538   {
539     myTextureSetBits |= Graphic3d_TextureSetBits_Occlusion;
540     SetUniform (theCtx, aLocSampler, GLint(Graphic3d_TextureUnit_Occlusion));
541   }
542   if (const OpenGl_ShaderUniformLocation aLocSampler = GetUniformLocation (theCtx, "occSamplerNormal"))
543   {
544     myTextureSetBits |= Graphic3d_TextureSetBits_Normal;
545     SetUniform (theCtx, aLocSampler, GLint(Graphic3d_TextureUnit_Normal));
546   }
547   if (const OpenGl_ShaderUniformLocation aLocSampler = GetUniformLocation (theCtx, "occDiffIBLMapSHCoeffs"))
548   {
549     SetUniform (theCtx, aLocSampler, GLint(theCtx->PBRDiffIBLMapSHTexUnit()));
550   }
551   if (const OpenGl_ShaderUniformLocation aLocSampler = GetUniformLocation (theCtx, "occSpecIBLMap"))
552   {
553     SetUniform (theCtx, aLocSampler, GLint(theCtx->PBRSpecIBLMapTexUnit()));
554   }
555   if (const OpenGl_ShaderUniformLocation aLocSampler = GetUniformLocation (theCtx, "occEnvLUT"))
556   {
557     SetUniform (theCtx, aLocSampler, GLint(theCtx->PBREnvLUTTexUnit()));
558   }
559
560   const TCollection_AsciiString aSamplerNamePrefix ("occSampler");
561   const Standard_Integer aNbUnitsMax = Max (theCtx->MaxCombinedTextureUnits(), Graphic3d_TextureUnit_NB);
562   for (GLint aUnitIter = 0; aUnitIter < aNbUnitsMax; ++aUnitIter)
563   {
564     const TCollection_AsciiString aName = aSamplerNamePrefix + aUnitIter;
565     if (const OpenGl_ShaderUniformLocation aLocSampler = GetUniformLocation (theCtx, aName.ToCString()))
566     {
567       SetUniform (theCtx, aLocSampler, aUnitIter);
568     }
569   }
570
571   theCtx->core20fwd->glUseProgram (!anOldProgram.IsNull() ? anOldProgram->ProgramId() : OpenGl_ShaderProgram::NO_PROGRAM);
572   return Standard_True;
573 }
574
575 // =======================================================================
576 // function : ~OpenGl_ShaderProgram
577 // purpose  : Releases resources of shader program
578 // =======================================================================
579 OpenGl_ShaderProgram::~OpenGl_ShaderProgram()
580 {
581   Release (NULL);
582 }
583
584 // =======================================================================
585 // function : AttachShader
586 // purpose  : Attaches shader object to the program object
587 // =======================================================================
588 Standard_Boolean OpenGl_ShaderProgram::AttachShader (const Handle(OpenGl_Context)&      theCtx,
589                                                      const Handle(OpenGl_ShaderObject)& theShader)
590 {
591   if (myProgramID == NO_PROGRAM || theShader.IsNull())
592   {
593     return Standard_False;
594   }
595
596   for (OpenGl_ShaderList::Iterator anIter (myShaderObjects); anIter.More(); anIter.Next())
597   {
598     if (theShader == anIter.Value())
599     {
600       return Standard_False;
601     }
602   }
603
604   myShaderObjects.Append (theShader);
605   theCtx->core20fwd->glAttachShader (myProgramID, theShader->myShaderID);
606   return Standard_True;
607 }
608
609 // =======================================================================
610 // function : DetachShader
611 // purpose  : Detaches shader object to the program object
612 // =======================================================================
613 Standard_Boolean OpenGl_ShaderProgram::DetachShader (const Handle(OpenGl_Context)&      theCtx,
614                                                      const Handle(OpenGl_ShaderObject)& theShader)
615 {
616   if (myProgramID == NO_PROGRAM
617    || theShader.IsNull())
618   {
619     return Standard_False;
620   }
621
622   OpenGl_ShaderList::Iterator anIter (myShaderObjects);
623   while (anIter.More())
624   {
625     if (theShader == anIter.Value())
626     {
627       myShaderObjects.Remove (anIter);
628       break;
629     }
630
631     anIter.Next();
632   }
633
634   if (!anIter.More())
635   {
636     return Standard_False;
637   }
638
639   theCtx->core20fwd->glDetachShader (myProgramID, theShader->myShaderID);
640   return Standard_True;
641 }
642
643 // =======================================================================
644 // function : Link
645 // purpose  : Links the program object
646 // =======================================================================
647 Standard_Boolean OpenGl_ShaderProgram::link (const Handle(OpenGl_Context)& theCtx)
648 {
649   if (myProgramID == NO_PROGRAM)
650   {
651     return Standard_False;
652   }
653
654   GLint aStatus = GL_FALSE;
655   theCtx->core20fwd->glLinkProgram (myProgramID);
656   theCtx->core20fwd->glGetProgramiv (myProgramID, GL_LINK_STATUS, &aStatus);
657   if (aStatus == GL_FALSE)
658   {
659     return Standard_False;
660   }
661
662   memset (myCurrentState, 0, sizeof (myCurrentState));
663   for (GLint aVar = 0; aVar < OpenGl_OCCT_NUMBER_OF_STATE_VARIABLES; ++aVar)
664   {
665     myStateLocations[aVar] = GetUniformLocation (theCtx, PredefinedKeywords[aVar]);
666   }
667   return Standard_True;
668 }
669
670 // =======================================================================
671 // function : Link
672 // purpose  :
673 // =======================================================================
674 Standard_Boolean OpenGl_ShaderProgram::Link (const Handle(OpenGl_Context)& theCtx,
675                                              bool theIsVerbose)
676 {
677   if (!theIsVerbose)
678   {
679     return link (theCtx);
680   }
681
682   if (!link (theCtx))
683   {
684     TCollection_AsciiString aLog;
685     FetchInfoLog (theCtx, aLog);
686     if (aLog.IsEmpty())
687     {
688       aLog = "Linker log is empty.";
689     }
690     theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_ERROR, 0, GL_DEBUG_SEVERITY_HIGH,
691                          TCollection_AsciiString ("Failed to link program object [") + myResourceId + "]! Linker log:\n" + aLog);
692     return false;
693   }
694   else if (theCtx->caps->glslWarnings)
695   {
696     TCollection_AsciiString aLog;
697     FetchInfoLog (theCtx, aLog);
698     if (!aLog.IsEmpty()
699      && !aLog.IsEqual ("No errors.\n"))
700     {
701       theCtx->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_LOW,
702                            TCollection_AsciiString ("GLSL linker log [") + myResourceId +"]:\n" + aLog);
703     }
704   }
705   return true;
706 }
707
708 // =======================================================================
709 // function : FetchInfoLog
710 // purpose  : Fetches information log of the last link operation
711 // =======================================================================
712 Standard_Boolean OpenGl_ShaderProgram::FetchInfoLog (const Handle(OpenGl_Context)& theCtx,
713                                                      TCollection_AsciiString&      theOutput)
714 {
715   if (myProgramID == NO_PROGRAM)
716   {
717     return Standard_False;
718   }
719
720   GLint aLength = 0;
721   theCtx->core20fwd->glGetProgramiv (myProgramID, GL_INFO_LOG_LENGTH, &aLength);
722   if (aLength > 0)
723   {
724     GLchar* aLog = (GLchar*) alloca (aLength);
725     memset (aLog, 0, aLength);
726     theCtx->core20fwd->glGetProgramInfoLog (myProgramID, aLength, NULL, aLog);
727     theOutput = aLog;
728   }
729   return Standard_True;
730 }
731
732 // =======================================================================
733 // function : ApplyVariables
734 // purpose  : Fetches uniform variables from proxy shader program
735 // =======================================================================
736 Standard_Boolean OpenGl_ShaderProgram::ApplyVariables(const Handle(OpenGl_Context)& theCtx)
737 {
738   if (myProxy.IsNull() || myProxy->Variables().IsEmpty())
739   {
740     return Standard_False;
741   }
742
743   for (Graphic3d_ShaderVariableList::Iterator anIter (myProxy->Variables()); anIter.More(); anIter.Next())
744   {
745     mySetterSelector.Set (theCtx, anIter.Value(), this);
746   }
747
748   myProxy->ClearVariables();
749   return Standard_True;
750 }
751
752 // =======================================================================
753 // function : GetUniformLocation
754 // purpose  : Returns location (index) of the specific uniform variable
755 // =======================================================================
756 OpenGl_ShaderUniformLocation OpenGl_ShaderProgram::GetUniformLocation (const Handle(OpenGl_Context)& theCtx,
757                                                                        const GLchar*                 theName) const
758 {
759   return OpenGl_ShaderUniformLocation (myProgramID != NO_PROGRAM
760                                      ? theCtx->core20fwd->glGetUniformLocation (myProgramID, theName)
761                                      : INVALID_LOCATION);
762 }
763
764 // =======================================================================
765 // function : GetAttributeLocation
766 // purpose  : Returns location (index) of the generic vertex attribute
767 // =======================================================================
768 GLint OpenGl_ShaderProgram::GetAttributeLocation (const Handle(OpenGl_Context)& theCtx,
769                                                   const GLchar*                 theName) const
770 {
771   return myProgramID != NO_PROGRAM
772        ? theCtx->core20fwd->glGetAttribLocation (myProgramID, theName)
773        : INVALID_LOCATION;
774 }
775
776 // =======================================================================
777 // function : GetUniform
778 // purpose  : Returns the value of the integer uniform variable
779 // =======================================================================
780 Standard_Boolean OpenGl_ShaderProgram::GetUniform (const Handle(OpenGl_Context)& theCtx,
781                                                    const GLchar*                 theName,
782                                                    OpenGl_Vec4i&                 theValue) const
783 {
784   return GetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue);
785 }
786
787 // =======================================================================
788 // function : GetUniform
789 // purpose  : Returns the value of the integer uniform variable
790 // =======================================================================
791 Standard_Boolean OpenGl_ShaderProgram::GetUniform (const Handle(OpenGl_Context)& theCtx,
792                                                    GLint                         theLocation,
793                                                    OpenGl_Vec4i&                 theValue) const
794 {
795   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
796   {
797     return Standard_False;
798   }
799
800   theCtx->core20fwd->glGetUniformiv (myProgramID, theLocation, theValue);
801   return Standard_True;
802 }
803
804 // =======================================================================
805 // function : GetUniform
806 // purpose  : Returns the value of the floating-point uniform variable
807 // =======================================================================
808 Standard_Boolean OpenGl_ShaderProgram::GetUniform (const Handle(OpenGl_Context)& theCtx,
809                                                    const GLchar*                 theName,
810                                                    OpenGl_Vec4&                  theValue) const
811 {
812   return GetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue);
813 }
814
815 // =======================================================================
816 // function : GetUniform
817 // purpose  : Returns the value of the floating-point uniform variable
818 // =======================================================================
819 Standard_Boolean OpenGl_ShaderProgram::GetUniform (const Handle(OpenGl_Context)& theCtx,
820                                                    GLint                         theLocation,
821                                                    OpenGl_Vec4&                  theValue) const
822 {
823   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
824   {
825     return Standard_False;
826   }
827
828   theCtx->core20fwd->glGetUniformfv (myProgramID, theLocation, theValue);
829   return Standard_True;
830 }
831
832 // =======================================================================
833 // function : GetAttribute
834 // purpose  : Returns the integer vertex attribute
835 // =======================================================================
836 Standard_Boolean OpenGl_ShaderProgram::GetAttribute (const Handle(OpenGl_Context)& theCtx,
837                                                      const GLchar*                 theName,
838                                                      OpenGl_Vec4i&                 theValue) const
839 {
840   return GetAttribute (theCtx, GetAttributeLocation (theCtx, theName), theValue);
841 }
842
843 // =======================================================================
844 // function : GetAttribute
845 // purpose  : Returns the integer vertex attribute
846 // =======================================================================
847 Standard_Boolean OpenGl_ShaderProgram::GetAttribute (const Handle(OpenGl_Context)& theCtx,
848                                                      GLint                         theIndex,
849                                                      OpenGl_Vec4i&                 theValue) const
850 {
851   if (myProgramID == NO_PROGRAM || theIndex == INVALID_LOCATION)
852   {
853     return Standard_False;
854   }
855
856   theCtx->core20fwd->glGetVertexAttribiv (theIndex, GL_CURRENT_VERTEX_ATTRIB, theValue);
857   return Standard_True;
858 }
859
860 // =======================================================================
861 // function : GetAttribute
862 // purpose  : Returns the floating-point vertex attribute
863 // =======================================================================
864 Standard_Boolean OpenGl_ShaderProgram::GetAttribute (const Handle(OpenGl_Context)& theCtx,
865                                                      const GLchar*                 theName,
866                                                      OpenGl_Vec4&                  theValue) const
867 {
868   return GetAttribute (theCtx, GetAttributeLocation (theCtx, theName), theValue);
869 }
870
871 // =======================================================================
872 // function : GetAttribute
873 // purpose  : Returns the floating-point vertex attribute
874 // =======================================================================
875 Standard_Boolean OpenGl_ShaderProgram::GetAttribute (const Handle(OpenGl_Context)& theCtx,
876                                                      GLint                         theIndex,
877                                                      OpenGl_Vec4&                  theValue) const
878 {
879   if (myProgramID == NO_PROGRAM || theIndex == INVALID_LOCATION)
880   {
881     return Standard_False;
882   }
883
884   theCtx->core20fwd->glGetVertexAttribfv (theIndex, GL_CURRENT_VERTEX_ATTRIB, theValue);
885   return Standard_True;
886 }
887
888 // =======================================================================
889 // function : SetAttributeName
890 // purpose  :
891 // =======================================================================
892 Standard_Boolean OpenGl_ShaderProgram::SetAttributeName (const Handle(OpenGl_Context)& theCtx,
893                                                          GLint                         theIndex,
894                                                          const GLchar*                 theName)
895 {
896   theCtx->core20fwd->glBindAttribLocation (myProgramID, theIndex, theName);
897   return Standard_True;
898 }
899
900 // =======================================================================
901 // function : SetAttribute
902 // purpose  :
903 // =======================================================================
904 Standard_Boolean OpenGl_ShaderProgram::SetAttribute (const Handle(OpenGl_Context)& theCtx,
905                                                      const GLchar*                 theName,
906                                                      GLfloat                       theValue)
907 {
908   return SetAttribute (theCtx, GetAttributeLocation (theCtx, theName), theValue);
909 }
910
911 // =======================================================================
912 // function : SetAttribute
913 // purpose  :
914 // =======================================================================
915 Standard_Boolean OpenGl_ShaderProgram::SetAttribute (const Handle(OpenGl_Context)& theCtx,
916                                                      GLint                         theIndex,
917                                                      GLfloat                       theValue)
918 {
919   if (myProgramID == NO_PROGRAM || theIndex == INVALID_LOCATION)
920   {
921     return Standard_False;
922   }
923
924   theCtx->core20fwd->glVertexAttrib1f (theIndex, theValue);
925   return Standard_True;
926 }
927
928 // =======================================================================
929 // function : SetAttribute
930 // purpose  :
931 // =======================================================================
932 Standard_Boolean OpenGl_ShaderProgram::SetAttribute (const Handle(OpenGl_Context)& theCtx,
933                                                      const GLchar*                 theName,
934                                                      const OpenGl_Vec2&            theValue)
935 {
936   return SetAttribute (theCtx, GetAttributeLocation (theCtx, theName), theValue);
937 }
938
939 // =======================================================================
940 // function : SetAttribute
941 // purpose  :
942 // =======================================================================
943 Standard_Boolean OpenGl_ShaderProgram::SetAttribute (const Handle(OpenGl_Context)& theCtx,
944                                                      GLint                         theIndex,
945                                                      const OpenGl_Vec2&            theValue)
946 {
947   if (myProgramID == NO_PROGRAM || theIndex == INVALID_LOCATION)
948   {
949     return Standard_False;
950   }
951
952   theCtx->core20fwd->glVertexAttrib2fv (theIndex, theValue);
953   return Standard_True;
954 }
955
956 // =======================================================================
957 // function : SetAttribute
958 // purpose  :
959 // =======================================================================
960 Standard_Boolean OpenGl_ShaderProgram::SetAttribute (const Handle(OpenGl_Context)& theCtx,
961                                                      const GLchar*                 theName,
962                                                      const OpenGl_Vec3&            theValue)
963 {
964   return SetAttribute (theCtx, GetAttributeLocation (theCtx, theName), theValue);
965 }
966
967 // =======================================================================
968 // function : SetAttribute
969 // purpose  :
970 // =======================================================================
971 Standard_Boolean OpenGl_ShaderProgram::SetAttribute (const Handle(OpenGl_Context)& theCtx,
972                                                      GLint                         theIndex,
973                                                      const OpenGl_Vec3&            theValue)
974 {
975   if (myProgramID == NO_PROGRAM || theIndex == INVALID_LOCATION)
976   {
977     return Standard_False;
978   }
979
980   theCtx->core20fwd->glVertexAttrib3fv (theIndex, theValue);
981   return Standard_True;
982 }
983
984 // =======================================================================
985 // function : SetAttribute
986 // purpose  :
987 // =======================================================================
988 Standard_Boolean OpenGl_ShaderProgram::SetAttribute (const Handle(OpenGl_Context)& theCtx,
989                                                      const GLchar*                 theName,
990                                                      const OpenGl_Vec4&            theValue)
991 {
992   return SetAttribute (theCtx, GetAttributeLocation (theCtx, theName), theValue);
993 }
994
995 // =======================================================================
996 // function : SetAttribute
997 // purpose  :
998 // =======================================================================
999 Standard_Boolean OpenGl_ShaderProgram::SetAttribute (const Handle(OpenGl_Context)& theCtx,
1000                                                      GLint                         theIndex,
1001                                                      const OpenGl_Vec4&            theValue)
1002 {
1003   if (myProgramID == NO_PROGRAM || theIndex == INVALID_LOCATION)
1004   {
1005     return Standard_False;
1006   }
1007
1008   theCtx->core20fwd->glVertexAttrib4fv (theIndex, theValue);
1009   return Standard_True;
1010 }
1011
1012 // =======================================================================
1013 // function : SetUniform
1014 // purpose  : Specifies the value of the integer uniform variable
1015 // =======================================================================
1016 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1017                                                    const GLchar*                 theName,
1018                                                    GLint                         theValue)
1019 {
1020   return SetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue);
1021 }
1022
1023 // =======================================================================
1024 // function : SetUniform
1025 // purpose  : Specifies the value of the integer uniform variable
1026 // =======================================================================
1027 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1028                                                    GLint                         theLocation,
1029                                                    GLint                         theValue)
1030 {
1031   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1032   {
1033     return Standard_False;
1034   }
1035
1036   theCtx->core20fwd->glUniform1i (theLocation, theValue);
1037   return Standard_True;
1038 }
1039
1040 // =======================================================================
1041 // function : SetUniform
1042 // purpose  :
1043 // =======================================================================
1044 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1045                                                    const GLchar*                 theName,
1046                                                    const OpenGl_Vec2u&           theValue)
1047 {
1048   return SetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue);
1049 }
1050
1051 // =======================================================================
1052 // function : SetUniform
1053 // purpose  :
1054 // =======================================================================
1055 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1056                                                    GLint                         theLocation,
1057                                                    const OpenGl_Vec2u&           theValue)
1058 {
1059   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1060   {
1061     return false;
1062   }
1063
1064 #if !defined(GL_ES_VERSION_2_0)
1065   if (theCtx->core32 != NULL)
1066   {
1067     theCtx->core32->glUniform2uiv (theLocation, 1, theValue.GetData());
1068     return true;
1069   }
1070 #else
1071   if (theCtx->core30fwd != NULL)
1072   {
1073     theCtx->core30fwd->glUniform2uiv (theLocation, 1, theValue.GetData());
1074     return true;
1075   }
1076 #endif
1077   return false;
1078 }
1079
1080 // =======================================================================
1081 // function : SetUniform
1082 // purpose  :
1083 // =======================================================================
1084 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1085                                                    const GLchar*                 theName,
1086                                                    const GLsizei                 theCount,
1087                                                    const OpenGl_Vec2u*           theValue)
1088 {
1089   return SetUniform (theCtx, GetUniformLocation (theCtx, theName), theCount, theValue);
1090 }
1091
1092 // =======================================================================
1093 // function : SetUniform
1094 // purpose  :
1095 // =======================================================================
1096 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1097                                                    GLint                         theLocation,
1098                                                    const GLsizei                 theCount,
1099                                                    const OpenGl_Vec2u*           theValue)
1100 {
1101   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1102   {
1103     return false;
1104   }
1105
1106 #if !defined(GL_ES_VERSION_2_0)
1107   if (theCtx->core32 != NULL)
1108   {
1109     theCtx->core32->glUniform2uiv (theLocation, theCount, theValue->GetData());
1110     return true;
1111   }
1112 #else
1113   if (theCtx->core30fwd != NULL)
1114   {
1115     theCtx->core30fwd->glUniform2uiv (theLocation, theCount, theValue->GetData());
1116     return true;
1117   }
1118 #endif
1119   return false;
1120 }
1121
1122 // =======================================================================
1123 // function : SetUniform
1124 // purpose  : Specifies the value of the floating-point uniform variable
1125 // =======================================================================
1126 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1127                                                    const GLchar*                 theName,
1128                                                    GLfloat                       theValue)
1129 {
1130   return SetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue);
1131 }
1132
1133 // =======================================================================
1134 // function : SetUniform
1135 // purpose  : Specifies the value of the floating-point uniform variable
1136 // =======================================================================
1137 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1138                                                    GLint                         theLocation,
1139                                                    GLfloat                       theValue)
1140 {
1141   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1142   {
1143     return Standard_False;
1144   }
1145
1146   theCtx->core20fwd->glUniform1f (theLocation, theValue);
1147   return Standard_True;
1148 }
1149
1150 // =======================================================================
1151 // function : SetUniform
1152 // purpose  : Specifies the value of the integer uniform 2D vector
1153 // =======================================================================
1154 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1155                                                    const GLchar*                 theName,
1156                                                    const OpenGl_Vec2i&           theValue)
1157 {
1158   return SetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue);
1159 }
1160
1161 // =======================================================================
1162 // function : SetUniform
1163 // purpose  : Specifies the value of the integer uniform 2D vector
1164 // =======================================================================
1165 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1166                                                    GLint                         theLocation,
1167                                                    const OpenGl_Vec2i&           theValue)
1168 {
1169   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1170   {
1171     return Standard_False;
1172   }
1173
1174   theCtx->core20fwd->glUniform2iv (theLocation, 1, theValue);
1175   return Standard_True;
1176 }
1177
1178 // =======================================================================
1179 // function : SetUniform
1180 // purpose  : Specifies the value of the integer uniform 3D vector
1181 // =======================================================================
1182 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1183                                                    const GLchar*                 theName,
1184                                                    const OpenGl_Vec3i&           theValue)
1185 {
1186   return SetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue);
1187 }
1188
1189 // =======================================================================
1190 // function : SetUniform
1191 // purpose  : Specifies the value of the integer uniform 3D vector
1192 // =======================================================================
1193 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1194                                                    GLint                         theLocation,
1195                                                    const OpenGl_Vec3i&           theValue)
1196 {
1197   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1198   {
1199     return Standard_False;
1200   }
1201
1202   theCtx->core20fwd->glUniform3iv (theLocation, 1, theValue);
1203   return Standard_True;
1204 }
1205
1206 // =======================================================================
1207 // function : SetUniform
1208 // purpose  : Specifies the value of the integer uniform 4D vector
1209 // =======================================================================
1210 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1211                                                    const GLchar*                 theName,
1212                                                    const OpenGl_Vec4i&           theValue)
1213 {
1214   return SetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue);
1215 }
1216
1217 // =======================================================================
1218 // function : SetUniform
1219 // purpose  : Specifies the value of the integer uniform 4D vector
1220 // =======================================================================
1221 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1222                                                    GLint                         theLocation,
1223                                                    const OpenGl_Vec4i&           theValue)
1224 {
1225   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1226   {
1227     return Standard_False;
1228   }
1229
1230   theCtx->core20fwd->glUniform4iv (theLocation, 1, theValue);
1231   return Standard_True;
1232 }
1233
1234 // =======================================================================
1235 // function : SetUniform
1236 // purpose  : Specifies the value of the floating-point uniform 2D vector
1237 // =======================================================================
1238 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1239                                                    const GLchar*                 theName,
1240                                                    const OpenGl_Vec2&            theValue)
1241 {
1242   return SetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue);
1243 }
1244
1245 // =======================================================================
1246 // function : SetUniform
1247 // purpose  : Specifies the value of the floating-point uniform 2D vector
1248 // =======================================================================
1249 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1250                                                    GLint                         theLocation,
1251                                                    const OpenGl_Vec2&            theValue)
1252 {
1253   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1254   {
1255     return Standard_False;
1256   }
1257
1258   theCtx->core20fwd->glUniform2fv (theLocation, 1, theValue);
1259   return Standard_True;
1260 }
1261
1262 // =======================================================================
1263 // function : SetUniform
1264 // purpose  : Specifies the value of the floating-point uniform 3D vector
1265 // =======================================================================
1266 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1267                                                    const GLchar*                 theName,
1268                                                    const OpenGl_Vec3&            theValue)
1269 {
1270   return SetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue);
1271 }
1272
1273 // =======================================================================
1274 // function : SetUniform
1275 // purpose  : Specifies the value of the floating-point uniform 3D vector
1276 // =======================================================================
1277 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1278                                                    GLint                         theLocation,
1279                                                    const OpenGl_Vec3&            theValue)
1280 {
1281   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1282   {
1283     return Standard_False;
1284   }
1285
1286   theCtx->core20fwd->glUniform3fv (theLocation, 1, theValue);
1287   return Standard_True;
1288 }
1289
1290 // =======================================================================
1291 // function : SetUniform
1292 // purpose  : Specifies the value of the floating-point uniform 4D vector
1293 // =======================================================================
1294 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1295                                                    const GLchar*                 theName,
1296                                                    const OpenGl_Vec4&            theValue)
1297 {
1298   return SetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue);
1299 }
1300
1301 // =======================================================================
1302 // function : SetUniform
1303 // purpose  : Specifies the value of the floating-point uniform 4D vector
1304 // =======================================================================
1305 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1306                                                    GLint                         theLocation,
1307                                                    const OpenGl_Vec4&            theValue)
1308 {
1309   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1310   {
1311     return Standard_False;
1312   }
1313
1314   theCtx->core20fwd->glUniform4fv (theLocation, 1, theValue);
1315   return Standard_True;
1316 }
1317
1318 // =======================================================================
1319 // function : SetUniform
1320 // purpose  : Specifies the value of the floating-point uniform 4x4 matrix
1321 // =======================================================================
1322 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1323                                                    const GLchar*                 theName,
1324                                                    const OpenGl_Mat4&            theValue,
1325                                                    GLboolean                     theTranspose)
1326 {
1327   return SetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue, theTranspose);
1328 }
1329
1330 // =======================================================================
1331 // function : SetUniform
1332 // purpose  : Specifies the value of the floating-point uniform 4x4 matrix
1333 // =======================================================================
1334 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1335                                                    GLint                         theLocation,
1336                                                    const OpenGl_Mat4&            theValue,
1337                                                    GLboolean                     theTranspose)
1338 {
1339   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1340   {
1341     return Standard_False;
1342   }
1343
1344   theCtx->core20fwd->glUniformMatrix4fv (theLocation, 1, GL_FALSE, theTranspose ? theValue.Transposed() : theValue);
1345   return Standard_True;
1346 }
1347
1348 // =======================================================================
1349 // function : SetUniform
1350 // purpose  : Specifies the value of the floating-point uniform 4x4 matrix
1351 // =======================================================================
1352 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1353                                                    const GLchar*                 theName,
1354                                                    const OpenGl_Matrix&          theValue,
1355                                                    GLboolean                     theTranspose)
1356 {
1357   return SetUniform (theCtx, GetUniformLocation (theCtx, theName), theValue, theTranspose);
1358 }
1359
1360 // =======================================================================
1361 // function : SetUniform
1362 // purpose  : Specifies the value of the floating-point uniform 4x4 matrix
1363 // =======================================================================
1364 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1365                                                    GLint                         theLocation,
1366                                                    const OpenGl_Matrix&          theValue,
1367                                                    GLboolean                     theTranspose)
1368 {
1369   return SetUniform (theCtx, theLocation, OpenGl_Mat4::Map (*theValue.mat), theTranspose);
1370 }
1371
1372 // =======================================================================
1373 // function : SetUniform
1374 // purpose  : Specifies the value of the float uniform array
1375 // =======================================================================
1376 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1377                                                    GLint                         theLocation,
1378                                                    GLuint                        theCount,
1379                                                    const Standard_ShortReal*     theData)
1380 {
1381   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1382   {
1383     return Standard_False;
1384   }
1385
1386   theCtx->core20fwd->glUniform1fv (theLocation, theCount, theData);
1387   return Standard_True;
1388 }
1389
1390 // =======================================================================
1391 // function : SetUniform
1392 // purpose  : Specifies the value of the float2 uniform array
1393 // =======================================================================
1394 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1395                                                    GLint                         theLocation,
1396                                                    GLuint                        theCount,
1397                                                    const OpenGl_Vec2*            theData)
1398 {
1399   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1400   {
1401     return Standard_False;
1402   }
1403
1404   theCtx->core20fwd->glUniform2fv (theLocation, theCount, theData[0].GetData());
1405   return Standard_True;
1406 }
1407
1408 // =======================================================================
1409 // function : SetUniform
1410 // purpose  : Specifies the value of the float3 uniform array
1411 // =======================================================================
1412 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1413                                                    GLint                         theLocation,
1414                                                    GLuint                        theCount,
1415                                                    const OpenGl_Vec3*            theData)
1416 {
1417   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1418   {
1419     return Standard_False;
1420   }
1421
1422   theCtx->core20fwd->glUniform3fv (theLocation, theCount, theData[0].GetData());
1423   return Standard_True;
1424 }
1425
1426 // =======================================================================
1427 // function : SetUniform
1428 // purpose  : Specifies the value of the float4 uniform array
1429 // =======================================================================
1430 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1431                                                    GLint                         theLocation,
1432                                                    GLuint                        theCount,
1433                                                    const OpenGl_Vec4*            theData)
1434 {
1435   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1436   {
1437     return Standard_False;
1438   }
1439
1440   theCtx->core20fwd->glUniform4fv (theLocation, theCount, theData[0].GetData());
1441   return Standard_True;
1442 }
1443
1444 // =======================================================================
1445 // function : SetUniform
1446 // purpose  : Specifies the value of the integer uniform array
1447 // =======================================================================
1448 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1449                                                    GLint                         theLocation,
1450                                                    GLuint                        theCount,
1451                                                    const Standard_Integer*       theData)
1452 {
1453   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1454   {
1455     return Standard_False;
1456   }
1457
1458   theCtx->core20fwd->glUniform1iv (theLocation, theCount, theData);
1459   return Standard_True;
1460 }
1461
1462 // =======================================================================
1463 // function : SetUniform
1464 // purpose  : Specifies the value of the int2 uniform array
1465 // =======================================================================
1466 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1467                                                    GLint                         theLocation,
1468                                                    GLuint                        theCount,
1469                                                    const OpenGl_Vec2i*           theData)
1470 {
1471   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1472   {
1473     return Standard_False;
1474   }
1475
1476   theCtx->core20fwd->glUniform2iv (theLocation, theCount, theData[0].GetData());
1477   return Standard_True;
1478 }
1479
1480 // =======================================================================
1481 // function : SetUniform
1482 // purpose  : Specifies the value of the int3 uniform array
1483 // =======================================================================
1484 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1485                                                    GLint                         theLocation,
1486                                                    GLuint                        theCount,
1487                                                    const OpenGl_Vec3i*           theData)
1488 {
1489   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1490   {
1491     return Standard_False;
1492   }
1493
1494   theCtx->core20fwd->glUniform3iv (theLocation, theCount, theData[0].GetData());
1495   return Standard_True;
1496 }
1497
1498 // =======================================================================
1499 // function : SetUniform
1500 // purpose  : Specifies the value of the int4 uniform array
1501 // =======================================================================
1502 Standard_Boolean OpenGl_ShaderProgram::SetUniform (const Handle(OpenGl_Context)& theCtx,
1503                                                    GLint                         theLocation,
1504                                                    GLuint                        theCount,
1505                                                    const OpenGl_Vec4i*           theData)
1506 {
1507   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1508   {
1509     return Standard_False;
1510   }
1511
1512   theCtx->core20fwd->glUniform4iv (theLocation, theCount, theData[0].GetData());
1513   return Standard_True;
1514 }
1515
1516 // =======================================================================
1517 // function : SetSampler
1518 // purpose  : Specifies the value of the sampler uniform variable
1519 // =======================================================================
1520 Standard_Boolean OpenGl_ShaderProgram::SetSampler (const Handle(OpenGl_Context)& theCtx,
1521                                                    const GLchar*                 theName,
1522                                                    const Graphic3d_TextureUnit   theTextureUnit)
1523 {
1524   return SetSampler (theCtx, GetUniformLocation (theCtx, theName), theTextureUnit);
1525 }
1526
1527 // =======================================================================
1528 // function : SetSampler
1529 // purpose  : Specifies the value of the sampler uniform variable
1530 // =======================================================================
1531 Standard_Boolean OpenGl_ShaderProgram::SetSampler (const Handle(OpenGl_Context)& theCtx,
1532                                                    GLint                         theLocation,
1533                                                    const Graphic3d_TextureUnit   theTextureUnit)
1534 {
1535   if (myProgramID == NO_PROGRAM || theLocation == INVALID_LOCATION)
1536   {
1537     return Standard_False;
1538   }
1539
1540   theCtx->core20fwd->glUniform1i (theLocation, theTextureUnit);
1541   return Standard_True;
1542 }
1543
1544 // =======================================================================
1545 // function : Create
1546 // purpose  : Creates new empty shader program of specified type
1547 // =======================================================================
1548 Standard_Boolean OpenGl_ShaderProgram::Create (const Handle(OpenGl_Context)& theCtx)
1549 {
1550   if (myProgramID == NO_PROGRAM
1551    && theCtx->core20fwd != NULL)
1552   {
1553     myProgramID = theCtx->core20fwd->glCreateProgram();
1554   }
1555
1556   return myProgramID != NO_PROGRAM;
1557 }
1558
1559 // =======================================================================
1560 // function : Release
1561 // purpose  : Destroys shader program
1562 // =======================================================================
1563 void OpenGl_ShaderProgram::Release (OpenGl_Context* theCtx)
1564 {
1565   if (myProgramID == NO_PROGRAM)
1566   {
1567     return;
1568   }
1569
1570   Standard_ASSERT_RETURN (theCtx != NULL,
1571     "OpenGl_ShaderProgram destroyed without GL context! Possible GPU memory leakage...",);
1572
1573   for (OpenGl_ShaderList::Iterator anIter (myShaderObjects); anIter.More(); anIter.Next())
1574   {
1575     if (!anIter.Value().IsNull())
1576     {
1577       anIter.ChangeValue()->Release (theCtx);
1578       anIter.ChangeValue().Nullify();
1579     }
1580   }
1581
1582   if (theCtx->core20fwd != NULL
1583    && theCtx->IsValid())
1584   {
1585     theCtx->core20fwd->glDeleteProgram (myProgramID);
1586   }
1587
1588   myProgramID = NO_PROGRAM;
1589 }
1590
1591 // =======================================================================
1592 // function : UpdateDebugDump
1593 // purpose  :
1594 // =======================================================================
1595 Standard_Boolean OpenGl_ShaderProgram::UpdateDebugDump (const Handle(OpenGl_Context)& theCtx,
1596                                                         const TCollection_AsciiString& theFolder,
1597                                                         Standard_Boolean theToBeautify,
1598                                                         Standard_Boolean theToReset)
1599 {
1600   if (myProgramID == NO_PROGRAM)
1601   {
1602     return Standard_False;
1603   }
1604
1605   TCollection_AsciiString aFolder = theFolder;
1606   if (aFolder.IsEmpty())
1607   {
1608     OSD_Environment aShaderVar ("CSF_ShadersDirectoryDump");
1609     aFolder = aShaderVar.Value();
1610     if (aFolder.IsEmpty())
1611     {
1612       aFolder = ".";
1613     }
1614   }
1615
1616   bool hasUpdates = false;
1617   for (OpenGl_ShaderList::Iterator anIter (myShaderObjects); anIter.More(); anIter.Next())
1618   {
1619     if (!anIter.Value().IsNull())
1620     {
1621       // desktop OpenGL (but not OpenGL ES) allows multiple shaders of the same stage to be attached,
1622       // but here we expect only single source per stage
1623       hasUpdates = anIter.ChangeValue()->updateDebugDump (theCtx, myResourceId, aFolder, theToBeautify, theToReset) || hasUpdates;
1624     }
1625   }
1626   if (hasUpdates)
1627   {
1628     return Link (theCtx);
1629   }
1630   return Standard_False;
1631 }