0031302: Visualization, TKOpenGl - wrong tangent space calculation for normal maps
[occt.git] / src / OpenGl / OpenGl_ShaderManager.cxx
1 // Created on: 2013-09-26
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 <typeinfo>
17
18 #include <Graphic3d_TextureParams.hxx>
19 #include <OpenGl_Aspects.hxx>
20 #include <OpenGl_ClippingIterator.hxx>
21 #include <OpenGl_Context.hxx>
22 #include <Graphic3d_CubeMapPacked.hxx>
23 #include <OpenGl_ShaderManager.hxx>
24 #include <OpenGl_ShaderProgram.hxx>
25 #include <OpenGl_VertexBufferCompat.hxx>
26 #include <OpenGl_PointSprite.hxx>
27 #include <OpenGl_Workspace.hxx>
28 #include <TCollection_ExtendedString.hxx>
29
30 #include "../Shaders/Shaders_PBRDistribution_glsl.pxx"
31 #include "../Shaders/Shaders_PBRGeometry_glsl.pxx"
32 #include "../Shaders/Shaders_PBRFresnel_glsl.pxx"
33 #include "../Shaders/Shaders_PBRCookTorrance_glsl.pxx"
34 #include "../Shaders/Shaders_PBRIllumination_glsl.pxx"
35 #include "../Shaders/Shaders_PBREnvBaking_fs.pxx"
36 #include "../Shaders/Shaders_PBREnvBaking_vs.pxx"
37 #include "../Shaders/Shaders_PointLightAttenuation_glsl.pxx"
38
39 IMPLEMENT_STANDARD_RTTIEXT(OpenGl_ShaderManager,Standard_Transient)
40
41 namespace
42 {
43   //! Number specifying maximum number of light sources to prepare a GLSL program with unrolled loop.
44   const Standard_Integer THE_NB_UNROLLED_LIGHTS_MAX = 32;
45
46   //! Compute the size of array storing holding light sources definition.
47   static Standard_Integer roundUpMaxLightSources (Standard_Integer theNbLights)
48   {
49     Standard_Integer aMaxLimit = THE_NB_UNROLLED_LIGHTS_MAX;
50     for (; aMaxLimit < theNbLights; aMaxLimit *= 2) {}
51     return aMaxLimit;
52   }
53
54 #define EOL "\n"
55
56 //! Compute TexCoord value in Vertex Shader
57 const char THE_VARY_TexCoord_Trsf[] =
58   EOL"  float aRotSin = occTextureTrsf_RotationSin();"
59   EOL"  float aRotCos = occTextureTrsf_RotationCos();"
60   EOL"  vec2  aTex2   = (occTexCoord.xy + occTextureTrsf_Translation()) * occTextureTrsf_Scale();"
61   EOL"  vec2  aCopy   = aTex2;"
62   EOL"  aTex2.x = aCopy.x * aRotCos - aCopy.y * aRotSin;"
63   EOL"  aTex2.y = aCopy.x * aRotSin + aCopy.y * aRotCos;"
64   EOL"  TexCoord = vec4(aTex2, occTexCoord.zw);";
65
66 //! Auxiliary function to flip gl_PointCoord vertically
67 #define THE_VEC2_glPointCoord "vec2 (gl_PointCoord.x, 1.0 - gl_PointCoord.y)"
68
69 //! Auxiliary function to transform normal from model to view coordinate system.
70 const char THE_FUNC_transformNormal_view[] =
71   EOL"vec3 transformNormal (in vec3 theNormal)"
72   EOL"{"
73   EOL"  vec4 aResult = occWorldViewMatrixInverseTranspose"
74   EOL"               * occModelWorldMatrixInverseTranspose"
75   EOL"               * vec4 (theNormal, 0.0);"
76   EOL"  return normalize (aResult.xyz);"
77   EOL"}";
78
79 //! The same function as THE_FUNC_transformNormal but is used in PBR pipeline.
80 //! The normals are expected to be in world coordinate system in PBR pipeline.
81 const char THE_FUNC_transformNormal_world[] =
82   EOL"vec3 transformNormal (in vec3 theNormal)"
83   EOL"{"
84   EOL"  vec4 aResult = occModelWorldMatrixInverseTranspose"
85   EOL"               * vec4 (theNormal, 0.0);"
86   EOL"  return normalize (aResult.xyz);"
87   EOL"}";
88
89 //! Global shader variable for color definition with lighting enabled.
90 const char THE_FUNC_lightDef[] =
91   EOL"vec3 Ambient;"   //!< Ambient  contribution of light sources
92   EOL"vec3 Diffuse;"   //!< Diffuse  contribution of light sources
93   EOL"vec3 Specular;"; //!< Specular contribution of light sources
94
95 //! Global shader variable for color definition with lighting enabled.
96 const char THE_FUNC_PBR_lightDef[] =
97   EOL"vec3  DirectLighting;" //!< Accumulator of direct lighting from light sources
98   EOL"vec4  BaseColor;"      //!< Base color (albedo) of material for PBR
99   EOL"float Metallic;"       //!< Metallic coefficient of material
100   EOL"float NormalizedRoughness;" //!< Normalized roughness coefficient of material
101   EOL"float Roughness;"      //!< Roughness coefficient of material
102   EOL"vec3  Emission;"       //!< Light intensity emitted by material
103   EOL"float IOR;";           //!< Material's index of refraction
104
105 //! Function computes contribution of isotropic point light source
106 const char THE_FUNC_pointLight[] =
107   EOL"void pointLight (in int  theId,"
108   EOL"                 in vec3 theNormal,"
109   EOL"                 in vec3 theView,"
110   EOL"                 in vec3 thePoint,"
111   EOL"                 in bool theIsFront)"
112   EOL"{"
113   EOL"  vec3 aLight = occLight_Position (theId);"
114   EOL"  if (!occLight_IsHeadlight (theId))"
115   EOL"  {"
116   EOL"    aLight = vec3 (occWorldViewMatrix * vec4 (aLight, 1.0));"
117   EOL"  }"
118   EOL"  aLight -= thePoint;"
119   EOL
120   EOL"  float aDist = length (aLight);"
121   EOL"  float aRange = occLight_Range (theId);"
122   EOL"  float anAtten = occPointLightAttenuation (aDist, aRange, occLight_LinearAttenuation (theId), occLight_ConstAttenuation (theId));"
123   EOL"  if (anAtten <= 0.0) return;"
124   EOL"  aLight /= aDist;"
125   EOL
126   EOL"  vec3 aHalf = normalize (aLight + theView);"
127   EOL
128   EOL"  vec3  aFaceSideNormal = theIsFront ? theNormal : -theNormal;"
129   EOL"  float aNdotL = max (0.0, dot (aFaceSideNormal, aLight));"
130   EOL"  float aNdotH = max (0.0, dot (aFaceSideNormal, aHalf ));"
131   EOL
132   EOL"  float aSpecl = 0.0;"
133   EOL"  if (aNdotL > 0.0)"
134   EOL"  {"
135   EOL"    aSpecl = pow (aNdotH, theIsFront ? occFrontMaterial_Shininess() : occBackMaterial_Shininess());"
136   EOL"  }"
137   EOL
138   EOL"  Diffuse  += occLight_Diffuse (theId) * aNdotL * anAtten;"
139   EOL"  Specular += occLight_Specular(theId) * aSpecl * anAtten;"
140   EOL"}";
141
142 //! Function computes contribution of isotropic point light source
143 const char THE_FUNC_PBR_pointLight[] =
144   EOL"void pointLight (in int  theId,"
145   EOL"                 in vec3 theNormal,"
146   EOL"                 in vec3 theView,"
147   EOL"                 in vec3 thePoint,"
148   EOL"                 in bool theIsFront)"
149   EOL"{"
150   EOL"  vec3 aLight = occLight_Position (theId);"
151   EOL"  if (occLight_IsHeadlight (theId))"
152   EOL"  {"
153   EOL"    aLight = vec3 (occWorldViewMatrixInverse * vec4 (aLight, 1.0));"
154   EOL"  }"
155   EOL"  aLight -= thePoint;"
156   EOL
157   EOL"  float aDist = length (aLight);"
158   EOL"  float aRange = occLight_Range (theId);"
159   EOL"  float anAtten = occPointLightAttenuation (aDist, aRange);"
160   EOL"  if (anAtten <= 0.0) return;"
161   EOL"  aLight /= aDist;"
162   EOL
163   EOL"  theNormal = theIsFront ? theNormal : -theNormal;"
164   EOL"  DirectLighting += occPBRIllumination (theView, aLight, theNormal,"
165   EOL"                                        BaseColor, Metallic, Roughness, IOR,"
166   EOL"                                        occLight_Specular (theId),"
167   EOL"                                        occLight_Intensity(theId) * anAtten);"
168   EOL"}";
169
170 //! Function computes contribution of spotlight source
171 const char THE_FUNC_spotLight[] =
172   EOL"void spotLight (in int  theId,"
173   EOL"                in vec3 theNormal,"
174   EOL"                in vec3 theView,"
175   EOL"                in vec3 thePoint,"
176   EOL"                in bool theIsFront)"
177   EOL"{"
178   EOL"  vec3 aLight   = occLight_Position      (theId);"
179   EOL"  vec3 aSpotDir = occLight_SpotDirection (theId);"
180   EOL"  if (!occLight_IsHeadlight (theId))"
181   EOL"  {"
182   EOL"    aLight   = vec3 (occWorldViewMatrix * vec4 (aLight,   1.0));"
183   EOL"    aSpotDir = vec3 (occWorldViewMatrix * vec4 (aSpotDir, 0.0));"
184   EOL"  }"
185   EOL"  aLight -= thePoint;"
186   EOL
187   EOL"  float aDist = length (aLight);"
188   EOL"  float aRange = occLight_Range (theId);"
189   EOL"  float anAtten = occPointLightAttenuation (aDist, aRange, occLight_LinearAttenuation (theId), occLight_ConstAttenuation (theId));"
190   EOL"  if (anAtten <= 0.0) return;"
191   EOL"  aLight /= aDist;"
192   EOL
193   EOL"  aSpotDir = normalize (aSpotDir);"
194   // light cone
195   EOL"  float aCosA = dot (aSpotDir, -aLight);"
196   EOL"  if (aCosA >= 1.0 || aCosA < cos (occLight_SpotCutOff (theId)))"
197   EOL"  {"
198   EOL"    return;"
199   EOL"  }"
200   EOL
201   EOL"  float anExponent = occLight_SpotExponent (theId);"
202   EOL"  if (anExponent > 0.0)"
203   EOL"  {"
204   EOL"    anAtten *= pow (aCosA, anExponent * 128.0);"
205   EOL"  }"
206   EOL
207   EOL"  vec3 aHalf = normalize (aLight + theView);"
208   EOL
209   EOL"  vec3  aFaceSideNormal = theIsFront ? theNormal : -theNormal;"
210   EOL"  float aNdotL = max (0.0, dot (aFaceSideNormal, aLight));"
211   EOL"  float aNdotH = max (0.0, dot (aFaceSideNormal, aHalf ));"
212   EOL
213   EOL"  float aSpecl = 0.0;"
214   EOL"  if (aNdotL > 0.0)"
215   EOL"  {"
216   EOL"    aSpecl = pow (aNdotH, theIsFront ? occFrontMaterial_Shininess() : occBackMaterial_Shininess());"
217   EOL"  }"
218   EOL
219   EOL"  Diffuse  += occLight_Diffuse (theId) * aNdotL * anAtten;"
220   EOL"  Specular += occLight_Specular(theId) * aSpecl * anAtten;"
221   EOL"}";
222
223 //! Function computes contribution of spotlight source
224   const char THE_FUNC_PBR_spotLight[] =
225   EOL"void spotLight (in int  theId,"
226   EOL"                in vec3 theNormal,"
227   EOL"                in vec3 theView,"
228   EOL"                in vec3 thePoint,"
229   EOL"                in bool theIsFront)"
230   EOL"{"
231   EOL"  vec3 aLight   = occLight_Position      (theId);"
232   EOL"  vec3 aSpotDir = occLight_SpotDirection (theId);"
233   EOL"  if (occLight_IsHeadlight (theId))"
234   EOL"  {"
235   EOL"    aLight   = vec3 (occWorldViewMatrixInverse * vec4 (aLight,   1.0));"
236   EOL"    aSpotDir = vec3 (occWorldViewMatrixInverse * vec4 (aSpotDir, 0.0));"
237   EOL"  }"
238   EOL"  aLight -= thePoint;"
239   EOL
240   EOL"  float aDist = length (aLight);"
241   EOL"  float aRange = occLight_Range (theId);"
242   EOL"  float anAtten = occPointLightAttenuation (aDist, aRange);"
243   EOL"  if (anAtten <= 0.0) return;"
244   EOL"  aLight /= aDist;"
245   EOL
246   EOL"  aSpotDir = normalize (aSpotDir);"
247   // light cone
248   EOL"  float aCosA = dot (aSpotDir, -aLight);"
249   EOL"  float aRelativeAngle = 2.0 * acos(aCosA) / occLight_SpotCutOff(theId);"
250   EOL"  if (aCosA >= 1.0 || aRelativeAngle > 1.0)"
251   EOL"  {"
252   EOL"    return;"
253   EOL"  }"
254   EOL"  float anExponent = occLight_SpotExponent (theId);"
255   EOL"  if ((1.0 - aRelativeAngle) <= anExponent)"
256   EOL"  {"
257   EOL"    float anAngularAttenuationOffset = cos(0.5 * occLight_SpotCutOff(theId));"
258   EOL"    float anAngularAttenuationScale = 1.0 / max(0.001, cos(0.5 * occLight_SpotCutOff(theId) * (1.0 - anExponent)) - anAngularAttenuationOffset);"
259   EOL"    anAngularAttenuationOffset *= -anAngularAttenuationScale;"
260   EOL"    float anAngularAttenuantion = clamp(aCosA * anAngularAttenuationScale + anAngularAttenuationOffset, 0.0, 1.0);"
261   EOL"    anAtten *= anAngularAttenuantion * anAngularAttenuantion;"
262   EOL"  }"
263   EOL"  theNormal = theIsFront ? theNormal : -theNormal;"
264   EOL"  DirectLighting += occPBRIllumination (theView, aLight, theNormal,"
265   EOL"                                        BaseColor, Metallic, Roughness, IOR,"
266   EOL"                                        occLight_Specular(theId),"
267   EOL"                                        occLight_Intensity(theId) * anAtten);"
268   EOL"}";
269
270 //! Function computes contribution of directional light source
271 const char THE_FUNC_directionalLight[] =
272   EOL"void directionalLight (in int  theId,"
273   EOL"                       in vec3 theNormal,"
274   EOL"                       in vec3 theView,"
275   EOL"                       in bool theIsFront)"
276   EOL"{"
277   EOL"  vec3 aLight = normalize (occLight_Position (theId));"
278   EOL"  if (!occLight_IsHeadlight (theId))"
279   EOL"  {"
280   EOL"    aLight = vec3 (occWorldViewMatrix * vec4 (aLight, 0.0));"
281   EOL"  }"
282   EOL
283   EOL"  vec3 aHalf = normalize (aLight + theView);"
284   EOL
285   EOL"  vec3  aFaceSideNormal = theIsFront ? theNormal : -theNormal;"
286   EOL"  float aNdotL = max (0.0, dot (aFaceSideNormal, aLight));"
287   EOL"  float aNdotH = max (0.0, dot (aFaceSideNormal, aHalf ));"
288   EOL
289   EOL"  float aSpecl = 0.0;"
290   EOL"  if (aNdotL > 0.0)"
291   EOL"  {"
292   EOL"    aSpecl = pow (aNdotH, theIsFront ? occFrontMaterial_Shininess() : occBackMaterial_Shininess());"
293   EOL"  }"
294   EOL
295   EOL"  Diffuse  += occLight_Diffuse  (theId) * aNdotL;"
296   EOL"  Specular += occLight_Specular (theId) * aSpecl;"
297   EOL"}";
298
299 //! Function computes contribution of directional light source
300 const char THE_FUNC_PBR_directionalLight[] =
301   EOL"void directionalLight (in int  theId,"
302   EOL"                       in vec3 theNormal,"
303   EOL"                       in vec3 theView,"
304   EOL"                       in bool theIsFront)"
305   EOL"{"
306   EOL"  vec3 aLight = normalize (occLight_Position (theId));"
307   EOL"  if (occLight_IsHeadlight (theId))"
308   EOL"  {"
309   EOL"    aLight = vec3 (occWorldViewMatrixInverse * vec4 (aLight, 0.0));"
310   EOL"  }"
311   EOL
312   EOL"  theNormal = theIsFront ? theNormal : -theNormal;"
313   EOL"  DirectLighting += occPBRIllumination (theView, aLight, theNormal,"
314   EOL"                                        BaseColor, Metallic, Roughness, IOR,"
315   EOL"                                        occLight_Specular (theId),"
316   EOL"                                        occLight_Intensity(theId));"
317   EOL"}";
318
319 //! The same as THE_FUNC_directionalLight but for the light with zero index
320 //! (avoids limitations on some mobile devices).
321 const char THE_FUNC_directionalLightFirst[] =
322   EOL"void directionalLightFirst (in vec3 theNormal,"
323   EOL"                            in vec3 theView,"
324   EOL"                            in bool theIsFront)"
325   EOL"{"
326   EOL"  vec3 aLight = normalize (occLight_Position(0));"
327   EOL"  if (!occLight_IsHeadlight (0))"
328   EOL"  {"
329   EOL"    aLight = vec3 (occWorldViewMatrix * vec4 (aLight, 0.0));"
330   EOL"  }"
331   EOL
332   EOL"  vec3 aHalf = normalize (aLight + theView);"
333   EOL
334   EOL"  vec3  aFaceSideNormal = theIsFront ? theNormal : -theNormal;"
335   EOL"  float aNdotL = max (0.0, dot (aFaceSideNormal, aLight));"
336   EOL"  float aNdotH = max (0.0, dot (aFaceSideNormal, aHalf ));"
337   EOL
338   EOL"  float aSpecl = 0.0;"
339   EOL"  if (aNdotL > 0.0)"
340   EOL"  {"
341   EOL"    aSpecl = pow (aNdotH, theIsFront ? occFrontMaterial_Shininess() : occBackMaterial_Shininess());"
342   EOL"  }"
343   EOL
344   EOL"  Diffuse  += occLight_Diffuse(0)  * aNdotL;"
345   EOL"  Specular += occLight_Specular(0) * aSpecl;"
346   EOL"}";
347
348 //! Returns the real cubemap fetching direction considering sides orientation, memory layout and vertical flip.
349 const char THE_FUNC_cubemap_vector_transform[] =
350   EOL"vec3 cubemapVectorTransform (in vec3 theVector,"
351   EOL"                             in int  theYCoeff,"
352   EOL"                             in int  theZCoeff)"
353   EOL"{"
354   EOL"  theVector = theVector.yzx;"
355   EOL"  theVector.y *= float(theYCoeff);"
356   EOL"  theVector.z *= float(theZCoeff);"
357   EOL"  return theVector;"
358   EOL"}";
359
360 //! Process clipping planes in Fragment Shader.
361 //! Should be added at the beginning of the main() function.
362 const char THE_FRAG_CLIP_PLANES_N[] =
363   EOL"  for (int aPlaneIter = 0; aPlaneIter < occClipPlaneCount; ++aPlaneIter)"
364   EOL"  {"
365   EOL"    vec4 aClipEquation = occClipPlaneEquations[aPlaneIter];"
366   EOL"    if (dot (aClipEquation.xyz, PositionWorld.xyz / PositionWorld.w) + aClipEquation.w < 0.0)"
367   EOL"    {"
368   EOL"      discard;"
369   EOL"    }"
370   EOL"  }";
371
372 //! Process chains of clipping planes in Fragment Shader.
373 const char THE_FRAG_CLIP_CHAINS_N[] =
374 EOL"  for (int aPlaneIter = 0; aPlaneIter < occClipPlaneCount;)"
375 EOL"  {"
376 EOL"    vec4 aClipEquation = occClipPlaneEquations[aPlaneIter];"
377 EOL"    if (dot (aClipEquation.xyz, PositionWorld.xyz / PositionWorld.w) + aClipEquation.w < 0.0)"
378 EOL"    {"
379 EOL"      if (occClipPlaneChains[aPlaneIter] == 1)"
380 EOL"      {"
381 EOL"        discard;"
382 EOL"      }"
383 EOL"      aPlaneIter += 1;"
384 EOL"    }"
385 EOL"    else"
386 EOL"    {"
387 EOL"      aPlaneIter += occClipPlaneChains[aPlaneIter];"
388 EOL"    }"
389 EOL"  }";
390
391 //! Process 1 clipping plane in Fragment Shader.
392 const char THE_FRAG_CLIP_PLANES_1[] =
393   EOL"  vec4 aClipEquation0 = occClipPlaneEquations[0];"
394   EOL"  if (dot (aClipEquation0.xyz, PositionWorld.xyz / PositionWorld.w) + aClipEquation0.w < 0.0)"
395   EOL"  {"
396   EOL"    discard;"
397   EOL"  }";
398
399 //! Process 2 clipping planes in Fragment Shader.
400 const char THE_FRAG_CLIP_PLANES_2[] =
401   EOL"  vec4 aClipEquation0 = occClipPlaneEquations[0];"
402   EOL"  vec4 aClipEquation1 = occClipPlaneEquations[1];"
403   EOL"  if (dot (aClipEquation0.xyz, PositionWorld.xyz / PositionWorld.w) + aClipEquation0.w < 0.0"
404   EOL"   || dot (aClipEquation1.xyz, PositionWorld.xyz / PositionWorld.w) + aClipEquation1.w < 0.0)"
405   EOL"  {"
406   EOL"    discard;"
407   EOL"  }";
408
409 //! Process a chain of 2 clipping planes in Fragment Shader (3/4 section).
410 const char THE_FRAG_CLIP_CHAINS_2[] =
411 EOL"  vec4 aClipEquation0 = occClipPlaneEquations[0];"
412 EOL"  vec4 aClipEquation1 = occClipPlaneEquations[1];"
413 EOL"  if (dot (aClipEquation0.xyz, PositionWorld.xyz / PositionWorld.w) + aClipEquation0.w < 0.0"
414 EOL"   && dot (aClipEquation1.xyz, PositionWorld.xyz / PositionWorld.w) + aClipEquation1.w < 0.0)"
415 EOL"  {"
416 EOL"    discard;"
417 EOL"  }";
418
419 //! Modify color for Wireframe presentation.
420 const char THE_FRAG_WIREFRAME_COLOR[] =
421 EOL"vec4 getFinalColor(void)"
422 EOL"{"
423 EOL"  float aDistance = min (min (EdgeDistance[0], EdgeDistance[1]), EdgeDistance[2]);"
424 EOL"  bool isHollow = occWireframeColor.a < 0.0;"
425 EOL"  float aMixVal = smoothstep (occLineWidth - occLineFeather * 0.5, occLineWidth + occLineFeather * 0.5, aDistance);"
426 EOL"  vec4 aMixColor = isHollow"
427 EOL"                 ? vec4 (getColor().rgb, 1.0 - aMixVal)"          // edges only (of interior color)
428 EOL"                 : mix (occWireframeColor, getColor(), aMixVal);" // interior + edges
429 EOL"  return aMixColor;"
430 EOL"}";
431
432 //! Compute gl_Position vertex shader output.
433 const char THE_VERT_gl_Position[] =
434 EOL"  gl_Position = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix * occVertex;";
435
436 //! Displace gl_Position alongside vertex normal for outline rendering.
437 //! This code adds silhouette only for smooth surfaces of closed primitive, and produces visual artifacts on sharp edges.
438 const char THE_VERT_gl_Position_OUTLINE[] =
439 EOL"  float anOutlineDisp = occOrthoScale > 0.0 ? occOrthoScale : gl_Position.w;"
440 EOL"  vec4  anOutlinePos  = occVertex + vec4 (occNormal * (occSilhouetteThickness * anOutlineDisp), 0.0);"
441 EOL"  gl_Position = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix * anOutlinePos;";
442
443 #if !defined(GL_ES_VERSION_2_0)
444
445   static const GLfloat THE_DEFAULT_AMBIENT[4]    = { 0.0f, 0.0f, 0.0f, 1.0f };
446   static const GLfloat THE_DEFAULT_SPOT_DIR[3]   = { 0.0f, 0.0f, -1.0f };
447   static const GLfloat THE_DEFAULT_SPOT_EXPONENT = 0.0f;
448   static const GLfloat THE_DEFAULT_SPOT_CUTOFF   = 180.0f;
449
450   //! Bind FFP light source.
451   static void bindLight (const Graphic3d_CLight& theLight,
452                          const GLenum        theLightGlId,
453                          const OpenGl_Mat4&  theModelView,
454                          OpenGl_Context*     theCtx)
455   {
456     // the light is a headlight?
457     if (theLight.IsHeadlight())
458     {
459       theCtx->core11->glMatrixMode (GL_MODELVIEW);
460       theCtx->core11->glLoadIdentity();
461     }
462
463     // setup light type
464     const Graphic3d_Vec4& aLightColor = theLight.PackedColor();
465     switch (theLight.Type())
466     {
467       case Graphic3d_TOLS_AMBIENT    : break; // handled by separate if-clause at beginning of method
468       case Graphic3d_TOLS_DIRECTIONAL:
469       {
470         // if the last parameter of GL_POSITION, is zero, the corresponding light source is a Directional one
471         const OpenGl_Vec4 anInfDir = -theLight.PackedDirectionRange();
472
473         // to create a realistic effect,  set the GL_SPECULAR parameter to the same value as the GL_DIFFUSE.
474         theCtx->core11->glLightfv (theLightGlId, GL_AMBIENT,               THE_DEFAULT_AMBIENT);
475         theCtx->core11->glLightfv (theLightGlId, GL_DIFFUSE,               aLightColor.GetData());
476         theCtx->core11->glLightfv (theLightGlId, GL_SPECULAR,              aLightColor.GetData());
477         theCtx->core11->glLightfv (theLightGlId, GL_POSITION,              anInfDir.GetData());
478         theCtx->core11->glLightfv (theLightGlId, GL_SPOT_DIRECTION,        THE_DEFAULT_SPOT_DIR);
479         theCtx->core11->glLightf  (theLightGlId, GL_SPOT_EXPONENT,         THE_DEFAULT_SPOT_EXPONENT);
480         theCtx->core11->glLightf  (theLightGlId, GL_SPOT_CUTOFF,           THE_DEFAULT_SPOT_CUTOFF);
481         break;
482       }
483       case Graphic3d_TOLS_POSITIONAL:
484       {
485         // to create a realistic effect, set the GL_SPECULAR parameter to the same value as the GL_DIFFUSE
486         const OpenGl_Vec4 aPosition (static_cast<float>(theLight.Position().X()), static_cast<float>(theLight.Position().Y()), static_cast<float>(theLight.Position().Z()), 1.0f);
487         theCtx->core11->glLightfv (theLightGlId, GL_AMBIENT,               THE_DEFAULT_AMBIENT);
488         theCtx->core11->glLightfv (theLightGlId, GL_DIFFUSE,               aLightColor.GetData());
489         theCtx->core11->glLightfv (theLightGlId, GL_SPECULAR,              aLightColor.GetData());
490         theCtx->core11->glLightfv (theLightGlId, GL_POSITION,              aPosition.GetData());
491         theCtx->core11->glLightfv (theLightGlId, GL_SPOT_DIRECTION,        THE_DEFAULT_SPOT_DIR);
492         theCtx->core11->glLightf  (theLightGlId, GL_SPOT_EXPONENT,         THE_DEFAULT_SPOT_EXPONENT);
493         theCtx->core11->glLightf  (theLightGlId, GL_SPOT_CUTOFF,           THE_DEFAULT_SPOT_CUTOFF);
494         theCtx->core11->glLightf  (theLightGlId, GL_CONSTANT_ATTENUATION,  theLight.ConstAttenuation());
495         theCtx->core11->glLightf  (theLightGlId, GL_LINEAR_ATTENUATION,    theLight.LinearAttenuation());
496         theCtx->core11->glLightf  (theLightGlId, GL_QUADRATIC_ATTENUATION, 0.0f);
497         break;
498       }
499       case Graphic3d_TOLS_SPOT:
500       {
501         const OpenGl_Vec4 aPosition (static_cast<float>(theLight.Position().X()), static_cast<float>(theLight.Position().Y()), static_cast<float>(theLight.Position().Z()), 1.0f);
502         theCtx->core11->glLightfv (theLightGlId, GL_AMBIENT,               THE_DEFAULT_AMBIENT);
503         theCtx->core11->glLightfv (theLightGlId, GL_DIFFUSE,               aLightColor.GetData());
504         theCtx->core11->glLightfv (theLightGlId, GL_SPECULAR,              aLightColor.GetData());
505         theCtx->core11->glLightfv (theLightGlId, GL_POSITION,              aPosition.GetData());
506         theCtx->core11->glLightfv (theLightGlId, GL_SPOT_DIRECTION,        theLight.PackedDirectionRange().GetData());
507         theCtx->core11->glLightf  (theLightGlId, GL_SPOT_EXPONENT,         theLight.Concentration() * 128.0f);
508         theCtx->core11->glLightf  (theLightGlId, GL_SPOT_CUTOFF,          (theLight.Angle() * 180.0f) / GLfloat(M_PI));
509         theCtx->core11->glLightf  (theLightGlId, GL_CONSTANT_ATTENUATION,  theLight.ConstAttenuation());
510         theCtx->core11->glLightf  (theLightGlId, GL_LINEAR_ATTENUATION,    theLight.LinearAttenuation());
511         theCtx->core11->glLightf  (theLightGlId, GL_QUADRATIC_ATTENUATION, 0.0f);
512         break;
513       }
514     }
515
516     // restore matrix in case of headlight
517     if (theLight.IsHeadlight())
518     {
519       theCtx->core11->glLoadMatrixf (theModelView.GetData());
520     }
521
522     glEnable (theLightGlId);
523   }
524 #endif
525
526   //! Generate map key for light sources configuration.
527   static TCollection_AsciiString genLightKey (const Handle(Graphic3d_LightSet)& theLights)
528   {
529     if (theLights->NbEnabled() <= THE_NB_UNROLLED_LIGHTS_MAX)
530     {
531       return TCollection_AsciiString ("l_") + theLights->KeyEnabledLong();
532     }
533
534     const Standard_Integer aMaxLimit = roundUpMaxLightSources (theLights->NbEnabled());
535     return TCollection_AsciiString ("l_") + theLights->KeyEnabledShort() + aMaxLimit;
536   }
537 }
538
539 // =======================================================================
540 // function : OpenGl_ShaderManager
541 // purpose  : Creates new empty shader manager
542 // =======================================================================
543 OpenGl_ShaderManager::OpenGl_ShaderManager (OpenGl_Context* theContext)
544 : myFfpProgram (new OpenGl_ShaderProgramFFP()),
545   myShadingModel (Graphic3d_TOSM_VERTEX),
546   myUnlitPrograms (new OpenGl_SetOfPrograms()),
547   myContext  (theContext),
548   mySRgbState (theContext->ToRenderSRGB()),
549   myHasLocalOrigin (Standard_False),
550   myLastView (NULL)
551 {
552   //
553 }
554
555 // =======================================================================
556 // function : ~OpenGl_ShaderManager
557 // purpose  : Releases resources of shader manager
558 // =======================================================================
559 OpenGl_ShaderManager::~OpenGl_ShaderManager()
560 {
561   myProgramList.Clear();
562   if (!myPBREnvironment.IsNull())
563   {
564     myPBREnvironment->Release (myContext);
565   }
566 }
567
568 // =======================================================================
569 // function : clear
570 // purpose  :
571 // =======================================================================
572 void OpenGl_ShaderManager::clear()
573 {
574   myProgramList.Clear();
575   myLightPrograms.Nullify();
576   myUnlitPrograms = new OpenGl_SetOfPrograms();
577   myOutlinePrograms.Nullify();
578   myMapOfLightPrograms.Clear();
579   myFontProgram.Nullify();
580   myBlitPrograms[0].Init (Handle(OpenGl_ShaderProgram)());
581   myBlitPrograms[1].Init (Handle(OpenGl_ShaderProgram)());
582   myBoundBoxProgram.Nullify();
583   myBoundBoxVertBuffer.Nullify();
584   for (Standard_Integer aModeIter = 0; aModeIter < Graphic3d_StereoMode_NB; ++aModeIter)
585   {
586     myStereoPrograms[aModeIter].Nullify();
587   }
588   switchLightPrograms();
589 }
590
591 // =======================================================================
592 // function : Create
593 // purpose  : Creates new shader program
594 // =======================================================================
595 Standard_Boolean OpenGl_ShaderManager::Create (const Handle(Graphic3d_ShaderProgram)& theProxy,
596                                                TCollection_AsciiString&               theShareKey,
597                                                Handle(OpenGl_ShaderProgram)&          theProgram)
598 {
599   theProgram.Nullify();
600   if (theProxy.IsNull())
601   {
602     return Standard_False;
603   }
604
605   theShareKey = theProxy->GetId();
606   if (myContext->GetResource<Handle(OpenGl_ShaderProgram)> (theShareKey, theProgram))
607   {
608     if (theProgram->Share())
609     {
610       myProgramList.Append (theProgram);
611     }
612     return Standard_True;
613   }
614
615   theProgram = new OpenGl_ShaderProgram (theProxy);
616   if (!theProgram->Initialize (myContext, theProxy->ShaderObjects()))
617   {
618     theProgram->Release (myContext);
619     theShareKey.Clear();
620     theProgram.Nullify();
621     return Standard_False;
622   }
623
624   myProgramList.Append (theProgram);
625   myContext->ShareResource (theShareKey, theProgram);
626   return Standard_True;
627 }
628
629 // =======================================================================
630 // function : Unregister
631 // purpose  : Removes specified shader program from the manager
632 // =======================================================================
633 void OpenGl_ShaderManager::Unregister (TCollection_AsciiString&      theShareKey,
634                                        Handle(OpenGl_ShaderProgram)& theProgram)
635 {
636   for (OpenGl_ShaderProgramList::Iterator anIt (myProgramList); anIt.More(); anIt.Next())
637   {
638     if (anIt.Value() == theProgram)
639     {
640       if (!theProgram->UnShare())
641       {
642         theShareKey.Clear();
643         theProgram.Nullify();
644         return;
645       }
646
647       myProgramList.Remove (anIt);
648       break;
649     }
650   }
651
652   const TCollection_AsciiString anID = theProgram->myProxy->GetId();
653   if (anID.IsEmpty())
654   {
655     myContext->DelayedRelease (theProgram);
656     theProgram.Nullify();
657   }
658   else
659   {
660     theProgram.Nullify();
661     myContext->ReleaseResource (anID, Standard_True);
662   }
663 }
664
665 // =======================================================================
666 // function : ShaderPrograms
667 // purpose  : Returns list of registered shader programs
668 // =======================================================================
669 const OpenGl_ShaderProgramList& OpenGl_ShaderManager::ShaderPrograms() const
670 {
671   return myProgramList;
672 }
673
674 // =======================================================================
675 // function : Empty
676 // purpose  : Returns true if no program objects are attached
677 // =======================================================================
678 Standard_Boolean OpenGl_ShaderManager::IsEmpty() const
679 {
680   return myProgramList.IsEmpty();
681 }
682
683 // =======================================================================
684 // function : switchLightPrograms
685 // purpose  :
686 // =======================================================================
687 void OpenGl_ShaderManager::switchLightPrograms()
688 {
689   const Handle(Graphic3d_LightSet)& aLights = myLightSourceState.LightSources();
690   if (aLights.IsNull())
691   {
692     if (!myMapOfLightPrograms.Find ("unlit", myLightPrograms))
693     {
694       myLightPrograms = new OpenGl_SetOfShaderPrograms (myUnlitPrograms);
695       myMapOfLightPrograms.Bind ("unlit", myLightPrograms);
696     }
697     return;
698   }
699
700   const TCollection_AsciiString aKey = genLightKey (aLights);
701   if (!myMapOfLightPrograms.Find (aKey, myLightPrograms))
702   {
703     myLightPrograms = new OpenGl_SetOfShaderPrograms();
704     myMapOfLightPrograms.Bind (aKey, myLightPrograms);
705   }
706 }
707
708 // =======================================================================
709 // function : UpdateSRgbState
710 // purpose  :
711 // =======================================================================
712 void OpenGl_ShaderManager::UpdateSRgbState()
713 {
714   if (mySRgbState == myContext->ToRenderSRGB())
715   {
716     return;
717   }
718
719   mySRgbState = myContext->ToRenderSRGB();
720
721   // special cases - GLSL programs dealing with sRGB/linearRGB internally
722   myStereoPrograms[Graphic3d_StereoMode_Anaglyph].Nullify();
723 }
724
725 // =======================================================================
726 // function : UpdateLightSourceStateTo
727 // purpose  : Updates state of OCCT light sources
728 // =======================================================================
729 void OpenGl_ShaderManager::UpdateLightSourceStateTo (const Handle(Graphic3d_LightSet)& theLights,
730                                                      Standard_Integer                  theSpecIBLMapLevels)
731 {
732   myLightSourceState.Set (theLights);
733   myLightSourceState.SetSpecIBLMapLevels (theSpecIBLMapLevels);
734   myLightSourceState.Update();
735   switchLightPrograms();
736 }
737
738 // =======================================================================
739 // function : UpdateLightSourceState
740 // purpose  :
741 // =======================================================================
742 void OpenGl_ShaderManager::UpdateLightSourceState()
743 {
744   myLightSourceState.Update();
745 }
746
747 // =======================================================================
748 // function : SetShadingModel
749 // purpose  :
750 // =======================================================================
751 void OpenGl_ShaderManager::SetShadingModel (const Graphic3d_TypeOfShadingModel theModel)
752 {
753   if (theModel == Graphic3d_TOSM_DEFAULT)
754   {
755     throw Standard_ProgramError ("OpenGl_ShaderManager::SetShadingModel() - attempt to set invalid Shading Model!");
756   }
757
758   myShadingModel = theModel;
759   switchLightPrograms();
760 }
761
762 // =======================================================================
763 // function : SetProjectionState
764 // purpose  : Sets new state of OCCT projection transform
765 // =======================================================================
766 void OpenGl_ShaderManager::UpdateProjectionStateTo (const OpenGl_Mat4& theProjectionMatrix)
767 {
768   myProjectionState.Set (theProjectionMatrix);
769   myProjectionState.Update();
770 }
771
772 // =======================================================================
773 // function : SetModelWorldState
774 // purpose  : Sets new state of OCCT model-world transform
775 // =======================================================================
776 void OpenGl_ShaderManager::UpdateModelWorldStateTo (const OpenGl_Mat4& theModelWorldMatrix)
777 {
778   myModelWorldState.Set (theModelWorldMatrix);
779   myModelWorldState.Update();
780 }
781
782 // =======================================================================
783 // function : SetWorldViewState
784 // purpose  : Sets new state of OCCT world-view transform
785 // =======================================================================
786 void OpenGl_ShaderManager::UpdateWorldViewStateTo (const OpenGl_Mat4& theWorldViewMatrix)
787 {
788   myWorldViewState.Set (theWorldViewMatrix);
789   myWorldViewState.Update();
790 }
791
792 // =======================================================================
793 // function : pushLightSourceState
794 // purpose  :
795 // =======================================================================
796 void OpenGl_ShaderManager::pushLightSourceState (const Handle(OpenGl_ShaderProgram)& theProgram) const
797 {
798   theProgram->UpdateState (OpenGl_LIGHT_SOURCES_STATE, myLightSourceState.Index());
799   if (theProgram == myFfpProgram)
800   {
801   #if !defined(GL_ES_VERSION_2_0)
802     if (myContext->core11 == NULL)
803     {
804       return;
805     }
806
807     GLenum aLightGlId = GL_LIGHT0;
808     const OpenGl_Mat4 aModelView = myWorldViewState.WorldViewMatrix() * myModelWorldState.ModelWorldMatrix();
809     for (Graphic3d_LightSet::Iterator aLightIt (myLightSourceState.LightSources(), Graphic3d_LightSet::IterationFilter_ExcludeDisabledAndAmbient);
810          aLightIt.More(); aLightIt.Next())
811     {
812       if (aLightGlId > GL_LIGHT7) // only 8 lights in FFP...
813       {
814         myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_MEDIUM,
815                                 "Warning: light sources limit (8) has been exceeded within Fixed-function pipeline.");
816         continue;
817       }
818
819       bindLight (*aLightIt.Value(), aLightGlId, aModelView, myContext);
820       ++aLightGlId;
821     }
822
823     // apply accumulated ambient color
824     const Graphic3d_Vec4 anAmbient = !myLightSourceState.LightSources().IsNull()
825                                     ? myLightSourceState.LightSources()->AmbientColor()
826                                     : Graphic3d_Vec4 (0.0f, 0.0f, 0.0f, 1.0f);
827     myContext->core11->glLightModelfv (GL_LIGHT_MODEL_AMBIENT, anAmbient.GetData());
828
829     // GL_LIGHTING is managed by drawers to switch between shaded / no lighting output,
830     // therefore managing the state here does not have any effect - do it just for consistency.
831     if (aLightGlId != GL_LIGHT0)
832     {
833       ::glEnable (GL_LIGHTING);
834     }
835     else
836     {
837       ::glDisable (GL_LIGHTING);
838     }
839     // switch off unused lights
840     for (; aLightGlId <= GL_LIGHT7; ++aLightGlId)
841     {
842       ::glDisable (aLightGlId);
843     }
844   #endif
845     return;
846   }
847
848   const Standard_Integer aNbLightsMax = theProgram->NbLightsMax();
849   const GLint anAmbientLoc = theProgram->GetStateLocation (OpenGl_OCC_LIGHT_AMBIENT);
850   if (aNbLightsMax == 0
851    && anAmbientLoc == OpenGl_ShaderProgram::INVALID_LOCATION)
852   {
853     return;
854   }
855
856   if (myLightTypeArray.Size() < aNbLightsMax)
857   {
858     myLightTypeArray  .Resize (0, aNbLightsMax - 1, false);
859     myLightParamsArray.Resize (0, aNbLightsMax - 1, false);
860   }
861   for (Standard_Integer aLightIt = 0; aLightIt < aNbLightsMax; ++aLightIt)
862   {
863     myLightTypeArray.SetValue (aLightIt, -1);
864   }
865
866   if (myLightSourceState.LightSources().IsNull()
867    || myLightSourceState.LightSources()->IsEmpty())
868   {
869     theProgram->SetUniform (myContext,
870                             theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_COUNT),
871                             0);
872     theProgram->SetUniform (myContext,
873                             anAmbientLoc,
874                             OpenGl_Vec4 (0.0f, 0.0f, 0.0f, 0.0f));
875     theProgram->SetUniform (myContext,
876                             theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_TYPES),
877                             aNbLightsMax,
878                             &myLightTypeArray.First());
879     return;
880   }
881
882   Standard_Integer aLightsNb = 0;
883   for (Graphic3d_LightSet::Iterator anIter (myLightSourceState.LightSources(), Graphic3d_LightSet::IterationFilter_ExcludeDisabledAndAmbient);
884        anIter.More(); anIter.Next())
885   {
886     const Graphic3d_CLight& aLight = *anIter.Value();
887     if (aLightsNb >= aNbLightsMax)
888     {
889       if (aNbLightsMax != 0)
890       {
891         myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_MEDIUM,
892                                 TCollection_AsciiString("Warning: light sources limit (") + aNbLightsMax + ") has been exceeded.");
893       }
894       continue;
895     }
896
897     Standard_Integer&             aLightType   = myLightTypeArray  .ChangeValue (aLightsNb);
898     OpenGl_ShaderLightParameters& aLightParams = myLightParamsArray.ChangeValue (aLightsNb);
899     if (!aLight.IsEnabled()) // has no affect with Graphic3d_LightSet::IterationFilter_ExcludeDisabled - here just for consistency
900     {
901       // if it is desired to keep disabled light in the same order - we can replace it with a black light so that it will have no influence on result
902       aLightType = -1; // Graphic3d_TOLS_AMBIENT can be used instead
903       aLightParams.Color = OpenGl_Vec4 (0.0f, 0.0f, 0.0f, 0.0f);
904       ++aLightsNb;
905       continue;
906     }
907
908     // ignoring OpenGl_Context::ToRenderSRGB() for light colors,
909     // as non-absolute colors for lights are rare and require tuning anyway
910     aLightType = aLight.Type();
911     aLightParams.Color     = aLight.PackedColor();
912     aLightParams.Color.a() = aLight.Intensity(); // used by PBR and ignored by old shading model
913     if (aLight.Type() == Graphic3d_TOLS_DIRECTIONAL)
914     {
915       aLightParams.Position = -aLight.PackedDirectionRange();
916     }
917     else if (!aLight.IsHeadlight())
918     {
919       aLightParams.Position.x() = static_cast<float>(aLight.Position().X() - myLocalOrigin.X());
920       aLightParams.Position.y() = static_cast<float>(aLight.Position().Y() - myLocalOrigin.Y());
921       aLightParams.Position.z() = static_cast<float>(aLight.Position().Z() - myLocalOrigin.Z());
922     }
923     else
924     {
925       aLightParams.Position.x() = static_cast<float>(aLight.Position().X());
926       aLightParams.Position.y() = static_cast<float>(aLight.Position().Y());
927       aLightParams.Position.z() = static_cast<float>(aLight.Position().Z());
928     }
929     aLightParams.Position.w() = aLight.IsHeadlight() ? 1.0f : 0.0f;
930
931     if (aLight.Type() == Graphic3d_TOLS_SPOT)
932     {
933       aLightParams.Direction = aLight.PackedDirectionRange();
934     }
935     if (aLight.Type() == Graphic3d_TOLS_POSITIONAL)
936     {
937       aLightParams.Direction.w() = aLight.Range();
938     }
939     aLightParams.Parameters = aLight.PackedParams();
940     ++aLightsNb;
941   }
942
943   const Graphic3d_Vec4& anAmbient = myLightSourceState.LightSources()->AmbientColor();
944   theProgram->SetUniform (myContext,
945                           theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_COUNT),
946                           aLightsNb);
947   theProgram->SetUniform (myContext,
948                           anAmbientLoc,
949                           anAmbient);
950   theProgram->SetUniform (myContext,
951                           theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_TYPES),
952                           aNbLightsMax,
953                           &myLightTypeArray.First());
954   if (aLightsNb > 0)
955   {
956     theProgram->SetUniform (myContext,
957                             theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_PARAMS),
958                             aLightsNb * OpenGl_ShaderLightParameters::NbOfVec4(),
959                             myLightParamsArray.First().Packed());
960   }
961
962   if (const OpenGl_ShaderUniformLocation aLocation = theProgram->GetStateLocation (OpenGl_OCCT_NB_SPEC_IBL_LEVELS))
963   {
964     theProgram->SetUniform (myContext, aLocation, myLightSourceState.SpecIBLMapLevels());
965   }
966 }
967
968 // =======================================================================
969 // function : pushProjectionState
970 // purpose  :
971 // =======================================================================
972 void OpenGl_ShaderManager::pushProjectionState (const Handle(OpenGl_ShaderProgram)& theProgram) const
973 {
974   theProgram->UpdateState (OpenGl_PROJECTION_STATE, myProjectionState.Index());
975   if (theProgram == myFfpProgram)
976   {
977   #if !defined(GL_ES_VERSION_2_0)
978     if (myContext->core11 != NULL)
979     {
980       myContext->core11->glMatrixMode (GL_PROJECTION);
981       myContext->core11->glLoadMatrixf (myProjectionState.ProjectionMatrix());
982     }
983   #endif
984     return;
985   }
986
987   theProgram->SetUniform (myContext,
988                           theProgram->GetStateLocation (OpenGl_OCC_PROJECTION_MATRIX),
989                           myProjectionState.ProjectionMatrix());
990
991   GLint aLocation = theProgram->GetStateLocation (OpenGl_OCC_PROJECTION_MATRIX_INVERSE);
992   if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
993   {
994     theProgram->SetUniform (myContext, aLocation, myProjectionState.ProjectionMatrixInverse());
995   }
996
997   theProgram->SetUniform (myContext,
998                           theProgram->GetStateLocation (OpenGl_OCC_PROJECTION_MATRIX_TRANSPOSE),
999                           myProjectionState.ProjectionMatrix(), true);
1000
1001   aLocation = theProgram->GetStateLocation (OpenGl_OCC_PROJECTION_MATRIX_INVERSE_TRANSPOSE);
1002   if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
1003   {
1004     theProgram->SetUniform (myContext, aLocation, myProjectionState.ProjectionMatrixInverse(), true);
1005   }
1006 }
1007
1008 // =======================================================================
1009 // function : pushModelWorldState
1010 // purpose  :
1011 // =======================================================================
1012 void OpenGl_ShaderManager::pushModelWorldState (const Handle(OpenGl_ShaderProgram)& theProgram) const
1013 {
1014   theProgram->UpdateState (OpenGl_MODEL_WORLD_STATE, myModelWorldState.Index());
1015   if (theProgram == myFfpProgram)
1016   {
1017   #if !defined(GL_ES_VERSION_2_0)
1018     if (myContext->core11 != NULL)
1019     {
1020       const OpenGl_Mat4 aModelView = myWorldViewState.WorldViewMatrix() * myModelWorldState.ModelWorldMatrix();
1021       myContext->core11->glMatrixMode (GL_MODELVIEW);
1022       myContext->core11->glLoadMatrixf (aModelView.GetData());
1023       theProgram->UpdateState (OpenGl_WORLD_VIEW_STATE, myWorldViewState.Index());
1024     }
1025   #endif
1026     return;
1027   }
1028
1029   theProgram->SetUniform (myContext,
1030                           theProgram->GetStateLocation (OpenGl_OCC_MODEL_WORLD_MATRIX),
1031                           myModelWorldState.ModelWorldMatrix());
1032
1033   GLint aLocation = theProgram->GetStateLocation (OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE);
1034   if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
1035   {
1036     theProgram->SetUniform (myContext, aLocation, myModelWorldState.ModelWorldMatrixInverse());
1037   }
1038
1039   theProgram->SetUniform (myContext,
1040                           theProgram->GetStateLocation (OpenGl_OCC_MODEL_WORLD_MATRIX_TRANSPOSE),
1041                           myModelWorldState.ModelWorldMatrix(), true);
1042
1043   aLocation = theProgram->GetStateLocation (OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE_TRANSPOSE);
1044   if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
1045   {
1046     theProgram->SetUniform (myContext, aLocation, myModelWorldState.ModelWorldMatrixInverse(), true);
1047   }
1048 }
1049
1050 // =======================================================================
1051 // function : pushWorldViewState
1052 // purpose  :
1053 // =======================================================================
1054 void OpenGl_ShaderManager::pushWorldViewState (const Handle(OpenGl_ShaderProgram)& theProgram) const
1055 {
1056   if (myWorldViewState.Index() == theProgram->ActiveState (OpenGl_WORLD_VIEW_STATE))
1057   {
1058     return;
1059   }
1060
1061   theProgram->UpdateState (OpenGl_WORLD_VIEW_STATE, myWorldViewState.Index());
1062   if (theProgram == myFfpProgram)
1063   {
1064   #if !defined(GL_ES_VERSION_2_0)
1065     if (myContext->core11 != NULL)
1066     {
1067       const OpenGl_Mat4 aModelView = myWorldViewState.WorldViewMatrix() * myModelWorldState.ModelWorldMatrix();
1068       myContext->core11->glMatrixMode (GL_MODELVIEW);
1069       myContext->core11->glLoadMatrixf (aModelView.GetData());
1070       theProgram->UpdateState (OpenGl_MODEL_WORLD_STATE, myModelWorldState.Index());
1071     }
1072   #endif
1073     return;
1074   }
1075
1076   theProgram->SetUniform (myContext,
1077                           theProgram->GetStateLocation (OpenGl_OCC_WORLD_VIEW_MATRIX),
1078                           myWorldViewState.WorldViewMatrix());
1079
1080   GLint aLocation = theProgram->GetStateLocation (OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE);
1081   if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
1082   {
1083     theProgram->SetUniform (myContext, aLocation, myWorldViewState.WorldViewMatrixInverse());
1084   }
1085
1086   theProgram->SetUniform (myContext,
1087                           theProgram->GetStateLocation (OpenGl_OCC_WORLD_VIEW_MATRIX_TRANSPOSE),
1088                           myWorldViewState.WorldViewMatrix(), true);
1089
1090   aLocation = theProgram->GetStateLocation (OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE_TRANSPOSE);
1091   if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
1092   {
1093     theProgram->SetUniform (myContext, aLocation, myWorldViewState.WorldViewMatrixInverse(), true);
1094   }
1095 }
1096
1097 // =======================================================================
1098 // function : UpdateClippingState
1099 // purpose  : Updates state of OCCT clipping planes
1100 // =======================================================================
1101 void OpenGl_ShaderManager::UpdateClippingState()
1102 {
1103   myClippingState.Update();
1104 }
1105
1106 // =======================================================================
1107 // function : RevertClippingState
1108 // purpose  : Reverts state of OCCT clipping planes
1109 // =======================================================================
1110 void OpenGl_ShaderManager::RevertClippingState()
1111 {
1112   myClippingState.Revert();
1113 }
1114
1115 // =======================================================================
1116 // function : pushClippingState
1117 // purpose  :
1118 // =======================================================================
1119 void OpenGl_ShaderManager::pushClippingState (const Handle(OpenGl_ShaderProgram)& theProgram) const
1120 {
1121   theProgram->UpdateState (OpenGl_CLIP_PLANES_STATE, myClippingState.Index());
1122   if (theProgram == myFfpProgram)
1123   {
1124   #if !defined(GL_ES_VERSION_2_0)
1125     if (myContext->core11 == NULL)
1126     {
1127       return;
1128     }
1129
1130     const Standard_Integer aNbMaxPlanes = myContext->MaxClipPlanes();
1131     if (myClipPlaneArrayFfp.Size() < aNbMaxPlanes)
1132     {
1133       myClipPlaneArrayFfp.Resize (0, aNbMaxPlanes - 1, false);
1134     }
1135
1136     Standard_Integer aPlaneId = 0;
1137     Standard_Boolean toRestoreModelView = Standard_False;
1138     const Handle(Graphic3d_ClipPlane)& aCappedChain = myContext->Clipping().CappedChain();
1139     for (OpenGl_ClippingIterator aPlaneIter (myContext->Clipping()); aPlaneIter.More(); aPlaneIter.Next())
1140     {
1141       const Handle(Graphic3d_ClipPlane)& aPlane = aPlaneIter.Value();
1142       if (aPlaneIter.IsDisabled()
1143        || aPlane->IsChain()
1144        || (aPlane == aCappedChain
1145         && myContext->Clipping().IsCappingEnableAllExcept()))
1146       {
1147         continue;
1148       }
1149       else if (aPlaneId >= aNbMaxPlanes)
1150       {
1151         myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_MEDIUM,
1152                                 TCollection_ExtendedString("Warning: clipping planes limit (") + aNbMaxPlanes + ") has been exceeded.");
1153         break;
1154       }
1155
1156       const Graphic3d_ClipPlane::Equation& anEquation = aPlane->GetEquation();
1157       OpenGl_Vec4d& aPlaneEq = myClipPlaneArrayFfp.ChangeValue (aPlaneId);
1158       aPlaneEq.x() = anEquation.x();
1159       aPlaneEq.y() = anEquation.y();
1160       aPlaneEq.z() = anEquation.z();
1161       aPlaneEq.w() = anEquation.w();
1162       if (myHasLocalOrigin)
1163       {
1164         const gp_XYZ        aPos = aPlane->ToPlane().Position().Location().XYZ() - myLocalOrigin;
1165         const Standard_Real aD   = -(anEquation.x() * aPos.X() + anEquation.y() * aPos.Y() + anEquation.z() * aPos.Z());
1166         aPlaneEq.w() = aD;
1167       }
1168
1169       const GLenum anFfpPlaneID = GL_CLIP_PLANE0 + aPlaneId;
1170       if (anFfpPlaneID == GL_CLIP_PLANE0)
1171       {
1172         // set either identity or pure view matrix
1173         toRestoreModelView = Standard_True;
1174         myContext->core11->glMatrixMode (GL_MODELVIEW);
1175         myContext->core11->glLoadMatrixf (myWorldViewState.WorldViewMatrix().GetData());
1176       }
1177
1178       ::glEnable (anFfpPlaneID);
1179       myContext->core11->glClipPlane (anFfpPlaneID, aPlaneEq);
1180
1181       ++aPlaneId;
1182     }
1183
1184     // switch off unused lights
1185     for (; aPlaneId < aNbMaxPlanes; ++aPlaneId)
1186     {
1187       ::glDisable (GL_CLIP_PLANE0 + aPlaneId);
1188     }
1189
1190     // restore combined model-view matrix
1191     if (toRestoreModelView)
1192     {
1193       const OpenGl_Mat4 aModelView = myWorldViewState.WorldViewMatrix() * myModelWorldState.ModelWorldMatrix();
1194       myContext->core11->glLoadMatrixf (aModelView.GetData());
1195     }
1196   #endif
1197     return;
1198   }
1199
1200   const GLint aLocEquations = theProgram->GetStateLocation (OpenGl_OCC_CLIP_PLANE_EQUATIONS);
1201   if (aLocEquations == OpenGl_ShaderProgram::INVALID_LOCATION)
1202   {
1203     return;
1204   }
1205
1206   const Standard_Integer aNbClipPlanesMax = theProgram->NbClipPlanesMax();
1207   const Standard_Integer aNbPlanes = Min (myContext->Clipping().NbClippingOrCappingOn(), aNbClipPlanesMax);
1208   if (aNbPlanes < 1)
1209   {
1210     theProgram->SetUniform (myContext, theProgram->GetStateLocation (OpenGl_OCC_CLIP_PLANE_COUNT), 0);
1211     return;
1212   }
1213
1214   if (myClipPlaneArray.Size() < aNbClipPlanesMax)
1215   {
1216     myClipPlaneArray.Resize (0, aNbClipPlanesMax - 1, false);
1217     myClipChainArray.Resize (0, aNbClipPlanesMax - 1, false);
1218   }
1219
1220   Standard_Integer aPlaneId = 0;
1221   const Handle(Graphic3d_ClipPlane)& aCappedChain = myContext->Clipping().CappedChain();
1222   for (OpenGl_ClippingIterator aPlaneIter (myContext->Clipping()); aPlaneIter.More(); aPlaneIter.Next())
1223   {
1224     const Handle(Graphic3d_ClipPlane)& aPlane = aPlaneIter.Value();
1225     if (aPlaneIter.IsDisabled())
1226     {
1227       continue;
1228     }
1229
1230     if (myContext->Clipping().IsCappingDisableAllExcept())
1231     {
1232       // enable only specific (sub) plane
1233       if (aPlane != aCappedChain)
1234       {
1235         continue;
1236       }
1237
1238       Standard_Integer aSubPlaneIndex = 1;
1239       for (const Graphic3d_ClipPlane* aSubPlaneIter = aCappedChain.get(); aSubPlaneIter != NULL; aSubPlaneIter = aSubPlaneIter->ChainNextPlane().get(), ++aSubPlaneIndex)
1240       {
1241         if (aSubPlaneIndex == myContext->Clipping().CappedSubPlane())
1242         {
1243           addClippingPlane (aPlaneId, *aSubPlaneIter, aSubPlaneIter->GetEquation(), 1);
1244           break;
1245         }
1246       }
1247       break;
1248     }
1249     else if (aPlane == aCappedChain) // && myContext->Clipping().IsCappingEnableAllExcept()
1250     {
1251       // enable sub-planes within processed Chain as reversed and ORed, excluding filtered plane
1252       if (aPlaneId + aPlane->NbChainNextPlanes() - 1 > aNbClipPlanesMax)
1253       {
1254         myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_HIGH,
1255                                 TCollection_AsciiString("Error: clipping planes limit (") + aNbClipPlanesMax + ") has been exceeded.");
1256         break;
1257       }
1258
1259       Standard_Integer aSubPlaneIndex = 1;
1260       for (const Graphic3d_ClipPlane* aSubPlaneIter = aPlane.get(); aSubPlaneIter != NULL; aSubPlaneIter = aSubPlaneIter->ChainNextPlane().get(), ++aSubPlaneIndex)
1261       {
1262         if (aSubPlaneIndex != -myContext->Clipping().CappedSubPlane())
1263         {
1264           addClippingPlane (aPlaneId, *aSubPlaneIter, aSubPlaneIter->ReversedEquation(), 1);
1265         }
1266       }
1267     }
1268     else
1269     {
1270       // normal case
1271       if (aPlaneId + aPlane->NbChainNextPlanes() > aNbClipPlanesMax)
1272       {
1273         myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_HIGH,
1274                                 TCollection_AsciiString("Error: clipping planes limit (") + aNbClipPlanesMax + ") has been exceeded.");
1275         break;
1276       }
1277       for (const Graphic3d_ClipPlane* aSubPlaneIter = aPlane.get(); aSubPlaneIter != NULL; aSubPlaneIter = aSubPlaneIter->ChainNextPlane().get())
1278       {
1279         addClippingPlane (aPlaneId, *aSubPlaneIter, aSubPlaneIter->GetEquation(), aSubPlaneIter->NbChainNextPlanes());
1280       }
1281     }
1282   }
1283
1284   theProgram->SetUniform (myContext, theProgram->GetStateLocation (OpenGl_OCC_CLIP_PLANE_COUNT), aPlaneId);
1285   theProgram->SetUniform (myContext, aLocEquations, aNbClipPlanesMax, &myClipPlaneArray.First());
1286   theProgram->SetUniform (myContext, theProgram->GetStateLocation (OpenGl_OCC_CLIP_PLANE_CHAINS), aNbClipPlanesMax, &myClipChainArray.First());
1287 }
1288
1289 // =======================================================================
1290 // function : pushMaterialState
1291 // purpose  :
1292 // =======================================================================
1293 void OpenGl_ShaderManager::pushMaterialState (const Handle(OpenGl_ShaderProgram)& theProgram) const
1294 {
1295   const OpenGl_Material& aFrontMat = myMaterialState.FrontMaterial();
1296   const OpenGl_Material& aBackMat  = myMaterialState.BackMaterial();
1297   theProgram->UpdateState (OpenGl_MATERIAL_STATE, myMaterialState.Index());
1298   if (theProgram == myFfpProgram)
1299   {
1300   #if !defined(GL_ES_VERSION_2_0)
1301     if (myContext->core11 == NULL)
1302     {
1303       return;
1304     }
1305
1306     if (myMaterialState.AlphaCutoff() < ShortRealLast())
1307     {
1308       glAlphaFunc (GL_GEQUAL, myMaterialState.AlphaCutoff());
1309       glEnable (GL_ALPHA_TEST);
1310     }
1311     else
1312     {
1313       glDisable (GL_ALPHA_TEST);
1314     }
1315
1316     const GLenum aFrontFace = myMaterialState.ToDistinguish() ? GL_FRONT : GL_FRONT_AND_BACK;
1317     myContext->core11->glMaterialfv(aFrontFace, GL_AMBIENT,   aFrontMat.Common.Ambient.GetData());
1318     myContext->core11->glMaterialfv(aFrontFace, GL_DIFFUSE,   aFrontMat.Common.Diffuse.GetData());
1319     myContext->core11->glMaterialfv(aFrontFace, GL_SPECULAR,  aFrontMat.Common.Specular.GetData());
1320     myContext->core11->glMaterialfv(aFrontFace, GL_EMISSION,  aFrontMat.Common.Emission.GetData());
1321     myContext->core11->glMaterialf (aFrontFace, GL_SHININESS, aFrontMat.Common.Shine());
1322     if (myMaterialState.ToDistinguish())
1323     {
1324       myContext->core11->glMaterialfv(GL_BACK, GL_AMBIENT,   aBackMat.Common.Ambient.GetData());
1325       myContext->core11->glMaterialfv(GL_BACK, GL_DIFFUSE,   aBackMat.Common.Diffuse.GetData());
1326       myContext->core11->glMaterialfv(GL_BACK, GL_SPECULAR,  aBackMat.Common.Specular.GetData());
1327       myContext->core11->glMaterialfv(GL_BACK, GL_EMISSION,  aBackMat.Common.Emission.GetData());
1328       myContext->core11->glMaterialf (GL_BACK, GL_SHININESS, aBackMat.Common.Shine());
1329     }
1330   #endif
1331     return;
1332   }
1333
1334   theProgram->SetUniform (myContext,
1335                           theProgram->GetStateLocation (OpenGl_OCCT_ALPHA_CUTOFF),
1336                           myMaterialState.AlphaCutoff());
1337   theProgram->SetUniform (myContext,
1338                           theProgram->GetStateLocation (OpenGl_OCCT_TEXTURE_ENABLE),
1339                           myMaterialState.ToMapTexture()  ? 1 : 0);
1340   theProgram->SetUniform (myContext,
1341                           theProgram->GetStateLocation (OpenGl_OCCT_DISTINGUISH_MODE),
1342                           myMaterialState.ToDistinguish() ? 1 : 0);
1343
1344   if (const OpenGl_ShaderUniformLocation& aLocPbrFront = theProgram->GetStateLocation (OpenGl_OCCT_PBR_FRONT_MATERIAL))
1345   {
1346     theProgram->SetUniform (myContext, aLocPbrFront, OpenGl_MaterialPBR::NbOfVec4(),
1347                             aFrontMat.Pbr.Packed());
1348   }
1349   if (const OpenGl_ShaderUniformLocation aLocPbrBack = theProgram->GetStateLocation (OpenGl_OCCT_PBR_BACK_MATERIAL))
1350   {
1351     theProgram->SetUniform (myContext, aLocPbrBack,  OpenGl_MaterialPBR::NbOfVec4(),
1352                             aBackMat.Pbr.Packed());
1353   }
1354   if (const OpenGl_ShaderUniformLocation aLocFront = theProgram->GetStateLocation (OpenGl_OCCT_COMMON_FRONT_MATERIAL))
1355   {
1356     theProgram->SetUniform (myContext, aLocFront, OpenGl_MaterialCommon::NbOfVec4(),
1357                             aFrontMat.Common.Packed());
1358   }
1359   if (const OpenGl_ShaderUniformLocation aLocBack = theProgram->GetStateLocation (OpenGl_OCCT_COMMON_BACK_MATERIAL))
1360   {
1361     theProgram->SetUniform (myContext, aLocBack,  OpenGl_MaterialCommon::NbOfVec4(),
1362                             aBackMat.Common.Packed());
1363   }
1364 }
1365
1366 // =======================================================================
1367 // function : pushOitState
1368 // purpose  :
1369 // =======================================================================
1370 void OpenGl_ShaderManager::pushOitState (const Handle(OpenGl_ShaderProgram)& theProgram) const
1371 {
1372   const GLint aLocOutput = theProgram->GetStateLocation (OpenGl_OCCT_OIT_OUTPUT);
1373   if (aLocOutput != OpenGl_ShaderProgram::INVALID_LOCATION)
1374   {
1375     theProgram->SetUniform (myContext, aLocOutput, myOitState.ToEnableWrite());
1376   }
1377
1378   const GLint aLocDepthFactor = theProgram->GetStateLocation (OpenGl_OCCT_OIT_DEPTH_FACTOR);
1379   if (aLocDepthFactor != OpenGl_ShaderProgram::INVALID_LOCATION)
1380   {
1381     theProgram->SetUniform (myContext, aLocDepthFactor, myOitState.DepthFactor());
1382   }
1383 }
1384
1385 // =======================================================================
1386 // function : PushInteriorState
1387 // purpose  :
1388 // =======================================================================
1389 void OpenGl_ShaderManager::PushInteriorState (const Handle(OpenGl_ShaderProgram)& theProgram,
1390                                               const Handle(Graphic3d_Aspects)& theAspect) const
1391 {
1392   if (theProgram.IsNull()
1393   || !theProgram->IsValid())
1394   {
1395     return;
1396   }
1397
1398   if (const OpenGl_ShaderUniformLocation aLocLineWidth = theProgram->GetStateLocation (OpenGl_OCCT_LINE_WIDTH))
1399   {
1400     theProgram->SetUniform (myContext, aLocLineWidth, theAspect->EdgeWidth() * myContext->LineWidthScale());
1401     theProgram->SetUniform (myContext, theProgram->GetStateLocation (OpenGl_OCCT_LINE_FEATHER), myContext->LineFeather() * myContext->LineWidthScale());
1402   }
1403   if (const OpenGl_ShaderUniformLocation aLocWireframeColor = theProgram->GetStateLocation (OpenGl_OCCT_WIREFRAME_COLOR))
1404   {
1405     if (theAspect->InteriorStyle() == Aspect_IS_HOLLOW)
1406     {
1407       theProgram->SetUniform (myContext, aLocWireframeColor, OpenGl_Vec4 (-1.0f, -1.0f, -1.0f, -1.0f));
1408     }
1409     else
1410     {
1411       theProgram->SetUniform (myContext, aLocWireframeColor, myContext->Vec4FromQuantityColor (theAspect->EdgeColorRGBA()));
1412     }
1413   }
1414   if (const OpenGl_ShaderUniformLocation aLocQuadModeState = theProgram->GetStateLocation (OpenGl_OCCT_QUAD_MODE_STATE))
1415   {
1416     theProgram->SetUniform (myContext, aLocQuadModeState, theAspect->ToSkipFirstEdge() ? 1 : 0);
1417   }
1418 }
1419
1420 // =======================================================================
1421 // function : PushState
1422 // purpose  : Pushes state of OCCT graphics parameters to the program
1423 // =======================================================================
1424 void OpenGl_ShaderManager::PushState (const Handle(OpenGl_ShaderProgram)& theProgram) const
1425 {
1426   const Handle(OpenGl_ShaderProgram)& aProgram = !theProgram.IsNull() ? theProgram : myFfpProgram;
1427   PushClippingState    (aProgram);
1428   PushWorldViewState   (aProgram);
1429   PushModelWorldState  (aProgram);
1430   PushProjectionState  (aProgram);
1431   PushLightSourceState (aProgram);
1432   PushMaterialState    (aProgram);
1433   PushOitState         (aProgram);
1434
1435   if (!theProgram.IsNull())
1436   {
1437     if (const OpenGl_ShaderUniformLocation& aLocViewPort = theProgram->GetStateLocation (OpenGl_OCCT_VIEWPORT))
1438     {
1439       theProgram->SetUniform (myContext, aLocViewPort, OpenGl_Vec4 ((float )myContext->Viewport()[0], (float )myContext->Viewport()[1],
1440                                                                     (float )myContext->Viewport()[2], (float )myContext->Viewport()[3]));
1441     }
1442   }
1443 }
1444
1445 // =======================================================================
1446 // function : prepareStdProgramFont
1447 // purpose  :
1448 // =======================================================================
1449 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramFont()
1450 {
1451   OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
1452   aUniforms   .Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D occSamplerBaseColor", Graphic3d_TOS_FRAGMENT));
1453   aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec2 TexCoord", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
1454
1455   TCollection_AsciiString aSrcVert = TCollection_AsciiString()
1456     + EOL"void main()"
1457       EOL"{"
1458       EOL"  TexCoord = occTexCoord.st;"
1459     + THE_VERT_gl_Position
1460     + EOL"}";
1461
1462   TCollection_AsciiString
1463     aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occSamplerBaseColor, TexCoord.st).a; }";
1464 #if !defined(GL_ES_VERSION_2_0)
1465   if (myContext->core11 == NULL)
1466   {
1467     aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occSamplerBaseColor, TexCoord.st).r; }";
1468   }
1469 #endif
1470
1471   TCollection_AsciiString aSrcFrag =
1472        aSrcGetAlpha
1473      + EOL"void main()"
1474        EOL"{"
1475        EOL"  vec4 aColor = occColor;"
1476        EOL"  aColor.a *= getAlpha();"
1477        EOL"  if (aColor.a <= 0.285) discard;"
1478        EOL"  occSetFragColor (aColor);"
1479        EOL"}";
1480
1481   Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
1482   defaultGlslVersion (aProgramSrc, "font", 0);
1483   aProgramSrc->SetDefaultSampler (false);
1484   aProgramSrc->SetNbLightsMax (0);
1485   aProgramSrc->SetNbClipPlanesMax (0);
1486   aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX,   aUniforms, aStageInOuts));
1487   aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts));
1488   TCollection_AsciiString aKey;
1489   if (!Create (aProgramSrc, aKey, myFontProgram))
1490   {
1491     myFontProgram = new OpenGl_ShaderProgram(); // just mark as invalid
1492     return Standard_False;
1493   }
1494   return Standard_True;
1495 }
1496
1497 // =======================================================================
1498 // function : BindFboBlitProgram
1499 // purpose  :
1500 // =======================================================================
1501 Standard_Boolean OpenGl_ShaderManager::BindFboBlitProgram (Standard_Integer theNbSamples,
1502                                                            Standard_Boolean theIsFallback_sRGB)
1503 {
1504   NCollection_Array1<Handle(OpenGl_ShaderProgram)>& aList = myBlitPrograms[theIsFallback_sRGB ? 1 : 0];
1505   Standard_Integer aNbSamples = Max (theNbSamples, 1);
1506   if (aNbSamples > aList.Upper())
1507   {
1508     aList.Resize (1, aNbSamples, true);
1509   }
1510
1511   Handle(OpenGl_ShaderProgram)& aProg = aList[aNbSamples];
1512   if (aProg.IsNull())
1513   {
1514     prepareStdProgramFboBlit (aProg, aNbSamples, theIsFallback_sRGB);
1515   }
1516   return !aProg.IsNull()
1517        && myContext->BindProgram (aProg);
1518 }
1519
1520 // =======================================================================
1521 // function : prepareStdProgramFboBlit
1522 // purpose  :
1523 // =======================================================================
1524 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramFboBlit (Handle(OpenGl_ShaderProgram)& theProgram,
1525                                                                  Standard_Integer theNbSamples,
1526                                                                  Standard_Boolean theIsFallback_sRGB)
1527 {
1528   OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
1529   aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec2 TexCoord", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
1530
1531   TCollection_AsciiString aSrcVert =
1532       EOL"void main()"
1533       EOL"{"
1534       EOL"  TexCoord    = occVertex.zw;"
1535       EOL"  gl_Position = vec4(occVertex.x, occVertex.y, 0.0, 1.0);"
1536       EOL"}";
1537
1538   TCollection_AsciiString aSrcFrag;
1539   if (theNbSamples > 1)
1540   {
1541   #if defined(GL_ES_VERSION_2_0)
1542     aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("highp sampler2DMS uColorSampler", Graphic3d_TOS_FRAGMENT));
1543     aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("highp sampler2DMS uDepthSampler", Graphic3d_TOS_FRAGMENT));
1544   #else
1545     aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2DMS uColorSampler", Graphic3d_TOS_FRAGMENT));
1546     aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2DMS uDepthSampler", Graphic3d_TOS_FRAGMENT));
1547   #endif
1548     aSrcFrag = TCollection_AsciiString()
1549     + EOL"#define THE_NUM_SAMPLES " + theNbSamples
1550     + (theIsFallback_sRGB ? EOL"#define THE_SHIFT_sRGB" : "")
1551     + EOL"void main()"
1552       EOL"{"
1553       EOL"  ivec2 aSize  = textureSize (uColorSampler);"
1554       EOL"  ivec2 anUV   = ivec2 (vec2 (aSize) * TexCoord);"
1555       EOL"  gl_FragDepth = texelFetch (uDepthSampler, anUV, THE_NUM_SAMPLES / 2 - 1).r;"
1556       EOL
1557       EOL"  vec4 aColor = vec4 (0.0);"
1558       EOL"  for (int aSample = 0; aSample < THE_NUM_SAMPLES; ++aSample)"
1559       EOL"  {"
1560       EOL"    vec4 aVal = texelFetch (uColorSampler, anUV, aSample);"
1561       EOL"    aColor += aVal;"
1562       EOL"  }"
1563       EOL"  aColor /= float(THE_NUM_SAMPLES);"
1564       EOL"#ifdef THE_SHIFT_sRGB"
1565       EOL"  aColor.rgb = pow (aColor.rgb, vec3 (1.0 / 2.2));"
1566       EOL"#endif"
1567       EOL"  occSetFragColor (aColor);"
1568       EOL"}";
1569   }
1570   else
1571   {
1572     aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D uColorSampler", Graphic3d_TOS_FRAGMENT));
1573     aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D uDepthSampler", Graphic3d_TOS_FRAGMENT));
1574     aSrcFrag = TCollection_AsciiString()
1575     + (theIsFallback_sRGB ? EOL"#define THE_SHIFT_sRGB" : "")
1576     + EOL"void main()"
1577       EOL"{"
1578       EOL"  gl_FragDepth = occTexture2D (uDepthSampler, TexCoord).r;"
1579       EOL"  vec4  aColor = occTexture2D (uColorSampler, TexCoord);"
1580       EOL"#ifdef THE_SHIFT_sRGB"
1581       EOL"  aColor.rgb = pow (aColor.rgb, vec3 (1.0 / 2.2));"
1582       EOL"#endif"
1583       EOL"  occSetFragColor (aColor);"
1584       EOL"}";
1585   }
1586
1587   Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
1588 #if defined(GL_ES_VERSION_2_0)
1589   if (myContext->IsGlGreaterEqual (3, 1))
1590   {
1591     // required for MSAA sampler
1592     aProgramSrc->SetHeader ("#version 310 es");
1593   }
1594   else if (myContext->IsGlGreaterEqual (3, 0))
1595   {
1596     aProgramSrc->SetHeader ("#version 300 es");
1597   }
1598   else if (myContext->extFragDepth)
1599   {
1600     aProgramSrc->SetHeader ("#extension GL_EXT_frag_depth : enable"
1601                          EOL"#define gl_FragDepth gl_FragDepthEXT");
1602   }
1603   else
1604   {
1605     // there is no way to draw into depth buffer
1606     aSrcFrag =
1607       EOL"void main()"
1608       EOL"{"
1609       EOL"  occSetFragColor (occTexture2D (uColorSampler, TexCoord));"
1610       EOL"}";
1611   }
1612 #else
1613   if (myContext->core32 != NULL)
1614   {
1615     aProgramSrc->SetHeader ("#version 150");
1616   }
1617 #endif
1618   TCollection_AsciiString anId = "occt_blit";
1619   if (theNbSamples > 1)
1620   {
1621     anId += TCollection_AsciiString ("_msaa") + theNbSamples;
1622   }
1623   if (theIsFallback_sRGB)
1624   {
1625     anId += "_gamma";
1626   }
1627   aProgramSrc->SetId (anId);
1628   aProgramSrc->SetDefaultSampler (false);
1629   aProgramSrc->SetNbLightsMax (0);
1630   aProgramSrc->SetNbClipPlanesMax (0);
1631   aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX,   aUniforms, aStageInOuts));
1632   aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts));
1633   TCollection_AsciiString aKey;
1634   if (!Create (aProgramSrc, aKey, theProgram))
1635   {
1636     theProgram = new OpenGl_ShaderProgram(); // just mark as invalid
1637     return Standard_False;
1638   }
1639
1640   myContext->BindProgram (theProgram);
1641   theProgram->SetSampler (myContext, "uColorSampler", Graphic3d_TextureUnit_0);
1642   theProgram->SetSampler (myContext, "uDepthSampler", Graphic3d_TextureUnit_1);
1643   myContext->BindProgram (NULL);
1644   return Standard_True;
1645 }
1646
1647 // =======================================================================
1648 // function : prepareStdProgramOitCompositing
1649 // purpose  :
1650 // =======================================================================
1651 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramOitCompositing (const Standard_Boolean theMsaa)
1652 {
1653   Handle(OpenGl_ShaderProgram)& aProgram = myOitCompositingProgram[theMsaa ? 1 : 0];
1654   Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
1655   TCollection_AsciiString aSrcVert, aSrcFrag;
1656
1657   OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
1658   aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec2 TexCoord", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
1659
1660   aSrcVert =
1661     EOL"void main()"
1662     EOL"{"
1663     EOL"  TexCoord    = occVertex.zw;"
1664     EOL"  gl_Position = vec4 (occVertex.x, occVertex.y, 0.0, 1.0);"
1665     EOL"}";
1666
1667   if (!theMsaa)
1668   {
1669     aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D uAccumTexture",  Graphic3d_TOS_FRAGMENT));
1670     aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D uWeightTexture", Graphic3d_TOS_FRAGMENT));
1671     aSrcFrag =
1672       EOL"void main()"
1673       EOL"{"
1674       EOL"  vec4 aAccum   = occTexture2D (uAccumTexture,  TexCoord);"
1675       EOL"  float aWeight = occTexture2D (uWeightTexture, TexCoord).r;"
1676       EOL"  occSetFragColor (vec4 (aAccum.rgb / max (aWeight, 0.00001), aAccum.a));"
1677       EOL"}";
1678   #if !defined(GL_ES_VERSION_2_0)
1679     if (myContext->IsGlGreaterEqual (3, 2))
1680     {
1681       aProgramSrc->SetHeader ("#version 150");
1682     }
1683   #else
1684     if (myContext->IsGlGreaterEqual (3, 0))
1685     {
1686       aProgramSrc->SetHeader ("#version 300 es");
1687     }
1688   #endif
1689   }
1690   else
1691   {
1692     aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2DMS uAccumTexture",  Graphic3d_TOS_FRAGMENT));
1693     aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2DMS uWeightTexture", Graphic3d_TOS_FRAGMENT));
1694     aSrcFrag =
1695       EOL"void main()"
1696       EOL"{"
1697       EOL"  ivec2 aTexel  = ivec2 (vec2 (textureSize (uAccumTexture)) * TexCoord);"
1698       EOL"  vec4 aAccum   = texelFetch (uAccumTexture,  aTexel, gl_SampleID);"
1699       EOL"  float aWeight = texelFetch (uWeightTexture, aTexel, gl_SampleID).r;"
1700       EOL"  occSetFragColor (vec4 (aAccum.rgb / max (aWeight, 0.00001), aAccum.a));"
1701       EOL"}";
1702   #if !defined(GL_ES_VERSION_2_0)
1703     if (myContext->IsGlGreaterEqual (4, 0))
1704     {
1705       aProgramSrc->SetHeader ("#version 400");
1706     }
1707   #else
1708     if (myContext->IsGlGreaterEqual (3, 2))
1709     {
1710       aProgramSrc->SetHeader ("#version 320 es");
1711     }
1712     else if (myContext->IsGlGreaterEqual (3, 0))
1713     {
1714       aProgramSrc->SetHeader ("#version 300 es"); // with GL_OES_sample_variables extension
1715     }
1716   #endif
1717   }
1718
1719   aProgramSrc->SetId (theMsaa ? "occt_weight-oit-msaa" : "occt_weight-oit");
1720   aProgramSrc->SetDefaultSampler (false);
1721   aProgramSrc->SetNbLightsMax (0);
1722   aProgramSrc->SetNbClipPlanesMax (0);
1723   aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX,   aUniforms, aStageInOuts));
1724   aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts));
1725   TCollection_AsciiString aKey;
1726   if (!Create (aProgramSrc, aKey, aProgram))
1727   {
1728     aProgram = new OpenGl_ShaderProgram(); // just mark as invalid
1729     return Standard_False;
1730   }
1731
1732   myContext->BindProgram (aProgram);
1733   aProgram->SetSampler (myContext, "uAccumTexture",  Graphic3d_TextureUnit_0);
1734   aProgram->SetSampler (myContext, "uWeightTexture", Graphic3d_TextureUnit_1);
1735   myContext->BindProgram (Handle(OpenGl_ShaderProgram)());
1736   return Standard_True;
1737 }
1738
1739 // =======================================================================
1740 // function : pointSpriteAlphaSrc
1741 // purpose  :
1742 // =======================================================================
1743 TCollection_AsciiString OpenGl_ShaderManager::pointSpriteAlphaSrc (Standard_Integer theBits)
1744 {
1745   TCollection_AsciiString aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occSamplerPointSprite, " THE_VEC2_glPointCoord ").a; }";
1746 #if !defined(GL_ES_VERSION_2_0)
1747   if (myContext->core11 == NULL
1748    && (theBits & OpenGl_PO_PointSpriteA) == OpenGl_PO_PointSpriteA)
1749   {
1750     aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occSamplerPointSprite, " THE_VEC2_glPointCoord ").r; }";
1751   }
1752 #else
1753   (void )theBits;
1754 #endif
1755   return aSrcGetAlpha;
1756 }
1757
1758 // =======================================================================
1759 // function : defaultGlslVersion
1760 // purpose  :
1761 // =======================================================================
1762 int OpenGl_ShaderManager::defaultGlslVersion (const Handle(Graphic3d_ShaderProgram)& theProgram,
1763                                               const TCollection_AsciiString& theName,
1764                                               int theBits,
1765                                               bool theUsesDerivates) const
1766 {
1767   int aBits = theBits;
1768   const bool toUseDerivates = theUsesDerivates
1769                           || (theBits & OpenGl_PO_StippleLine) != 0
1770                           || (theBits & OpenGl_PO_HasTextures) == OpenGl_PO_TextureNormal;
1771 #if !defined(GL_ES_VERSION_2_0)
1772   if (myContext->core32 != NULL)
1773   {
1774     theProgram->SetHeader ("#version 150");
1775   }
1776   else
1777   {
1778     if ((theBits & OpenGl_PO_StippleLine) != 0
1779      || theProgram->IsPBR())
1780     {
1781       if (myContext->IsGlGreaterEqual (3, 0))
1782       {
1783         theProgram->SetHeader ("#version 130");
1784       }
1785       else if (myContext->CheckExtension ("GL_EXT_gpu_shader4")) // myContext->hasGlslBitwiseOps == OpenGl_FeatureInExtensions
1786       {
1787         // GL_EXT_gpu_shader4 defines GLSL type "unsigned int", while core GLSL specs define type "uint"
1788         theProgram->SetHeader ("#extension GL_EXT_gpu_shader4 : enable\n"
1789                                "#define uint unsigned int");
1790       }
1791     }
1792   }
1793   (void )toUseDerivates;
1794 #else
1795
1796 #if defined(__EMSCRIPTEN__)
1797   if (myContext->IsGlGreaterEqual (3, 0))
1798   {
1799     // consider this is browser responsibility to provide working WebGL 2.0 implementation
1800     // and black-list broken drivers (there is no OpenGL ES greater than 3.0)
1801     theProgram->SetHeader ("#version 300 es");
1802   }
1803 #endif
1804   // prefer "100 es" on OpenGL ES 3.0- devices (save the features unavailable before "300 es")
1805   // and    "300 es" on OpenGL ES 3.1+ devices
1806   if (myContext->IsGlGreaterEqual (3, 1))
1807   {
1808     if ((theBits & OpenGl_PO_NeedsGeomShader) != 0)
1809     {
1810       theProgram->SetHeader (myContext->hasGeometryStage != OpenGl_FeatureInExtensions ? "#version 320 es" : "#version 310 es");
1811     }
1812     else
1813     {
1814       theProgram->SetHeader ("#version 300 es");
1815     }
1816   }
1817   else
1818   {
1819     if (theProgram->IsPBR()
1820      && myContext->IsGlGreaterEqual (3, 0))
1821     {
1822       theProgram->SetHeader ("#version 300 es");
1823     }
1824     if ((theBits & OpenGl_PO_WriteOit) != 0
1825      || (theBits & OpenGl_PO_StippleLine) != 0)
1826     {
1827       if (myContext->IsGlGreaterEqual (3, 0))
1828       {
1829         theProgram->SetHeader ("#version 300 es");
1830       }
1831       else
1832       {
1833         aBits = aBits & ~OpenGl_PO_WriteOit;
1834         if (!myContext->oesStdDerivatives)
1835         {
1836           aBits = aBits & ~OpenGl_PO_StippleLine;
1837         }
1838       }
1839     }
1840     if (toUseDerivates)
1841     {
1842       if (myContext->IsGlGreaterEqual (3, 0))
1843       {
1844         theProgram->SetHeader ("#version 300 es");
1845       }
1846       else if (myContext->oesStdDerivatives)
1847       {
1848         theProgram->SetHeader ("#extension GL_OES_standard_derivatives : enable");
1849       }
1850     }
1851   }
1852 #endif
1853
1854   // should fit OpenGl_PO_NB
1855   char aBitsStr[64];
1856   Sprintf (aBitsStr, "%04x", aBits);
1857   theProgram->SetId (TCollection_AsciiString ("occt_") + theName + aBitsStr);
1858   return aBits;
1859 }
1860
1861 // =======================================================================
1862 // function : prepareGeomMainSrc
1863 // purpose  :
1864 // =======================================================================
1865 TCollection_AsciiString OpenGl_ShaderManager::prepareGeomMainSrc (OpenGl_ShaderObject::ShaderVariableList& theUnifoms,
1866                                                                   OpenGl_ShaderObject::ShaderVariableList& theStageInOuts,
1867                                                                   Standard_Integer theBits)
1868 {
1869   if ((theBits & OpenGl_PO_NeedsGeomShader) == 0)
1870   {
1871     return TCollection_AsciiString();
1872   }
1873
1874   TCollection_AsciiString aSrcMainGeom =
1875     EOL"void main()"
1876     EOL"{";
1877
1878   if ((theBits & OpenGl_PO_MeshEdges) != 0)
1879   {
1880     theUnifoms.Append    (OpenGl_ShaderObject::ShaderVariable ("vec4 occViewport",       Graphic3d_TOS_GEOMETRY));
1881     theUnifoms.Append    (OpenGl_ShaderObject::ShaderVariable ("bool occIsQuadMode",     Graphic3d_TOS_GEOMETRY));
1882     theUnifoms.Append    (OpenGl_ShaderObject::ShaderVariable ("float occLineWidth",     Graphic3d_TOS_GEOMETRY));
1883     theUnifoms.Append    (OpenGl_ShaderObject::ShaderVariable ("float occLineWidth",     Graphic3d_TOS_FRAGMENT));
1884     theUnifoms.Append    (OpenGl_ShaderObject::ShaderVariable ("float occLineFeather",   Graphic3d_TOS_FRAGMENT));
1885     theUnifoms.Append    (OpenGl_ShaderObject::ShaderVariable ("vec4 occWireframeColor", Graphic3d_TOS_FRAGMENT));
1886     theStageInOuts.Append(OpenGl_ShaderObject::ShaderVariable ("vec3 EdgeDistance",      Graphic3d_TOS_GEOMETRY | Graphic3d_TOS_FRAGMENT));
1887
1888     aSrcMainGeom = TCollection_AsciiString()
1889     + EOL"vec3 ViewPortTransform (vec4 theVec)"
1890       EOL"{"
1891       EOL"  vec3 aWinCoord = theVec.xyz / theVec.w;"
1892       EOL"  aWinCoord    = aWinCoord * 0.5 + 0.5;"
1893       EOL"  aWinCoord.xy = aWinCoord.xy * occViewport.zw + occViewport.xy;"
1894       EOL"  return aWinCoord;"
1895       EOL"}"
1896     + aSrcMainGeom
1897     + EOL"  vec3 aSideA = ViewPortTransform (gl_in[2].gl_Position) - ViewPortTransform (gl_in[1].gl_Position);"
1898       EOL"  vec3 aSideB = ViewPortTransform (gl_in[2].gl_Position) - ViewPortTransform (gl_in[0].gl_Position);"
1899       EOL"  vec3 aSideC = ViewPortTransform (gl_in[1].gl_Position) - ViewPortTransform (gl_in[0].gl_Position);"
1900       EOL"  float aQuadArea = abs (aSideB.x * aSideC.y - aSideB.y * aSideC.x);"
1901       EOL"  vec3 aLenABC    = vec3 (length (aSideA), length (aSideB), length (aSideC));"
1902       EOL"  vec3 aHeightABC = vec3 (aQuadArea) / aLenABC;"
1903       EOL"  aHeightABC = max (aHeightABC, vec3 (10.0 * occLineWidth));" // avoid shrunk presentation disappearing at distance
1904       EOL"  float aQuadModeHeightC = occIsQuadMode ? occLineWidth + 1.0 : 0.0;";
1905   }
1906
1907   for (Standard_Integer aVertIter = 0; aVertIter < 3; ++aVertIter)
1908   {
1909     const TCollection_AsciiString aVertIndex (aVertIter);
1910     // pass variables from Vertex shader to Fragment shader through Geometry shader
1911     for (OpenGl_ShaderObject::ShaderVariableList::Iterator aVarListIter (theStageInOuts); aVarListIter.More(); aVarListIter.Next())
1912     {
1913       if (aVarListIter.Value().Stages == (Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT))
1914       {
1915         const TCollection_AsciiString aVarName = aVarListIter.Value().Name.Token (" ", 2);
1916         aSrcMainGeom += TCollection_AsciiString()
1917          + EOL"  geomOut." + aVarName + " = geomIn[" + aVertIndex + "]." + aVarName + ";";
1918       }
1919     }
1920
1921     if ((theBits & OpenGl_PO_MeshEdges) != 0)
1922     {
1923       switch (aVertIter)
1924       {
1925         case 0: aSrcMainGeom += EOL"  EdgeDistance = vec3 (aHeightABC[0], 0.0, aQuadModeHeightC);"; break;
1926         case 1: aSrcMainGeom += EOL"  EdgeDistance = vec3 (0.0, aHeightABC[1], aQuadModeHeightC);"; break;
1927         case 2: aSrcMainGeom += EOL"  EdgeDistance = vec3 (0.0, 0.0, aHeightABC[2]);"; break;
1928       }
1929     }
1930     aSrcMainGeom += TCollection_AsciiString()
1931      + EOL"  gl_Position = gl_in[" + aVertIndex + "].gl_Position;"
1932        EOL"  EmitVertex();";
1933   }
1934   aSrcMainGeom +=
1935     EOL"  EndPrimitive();"
1936     EOL"}";
1937
1938   return aSrcMainGeom;
1939 }
1940
1941 // =======================================================================
1942 // function : prepareStdProgramUnlit
1943 // purpose  :
1944 // =======================================================================
1945 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramUnlit (Handle(OpenGl_ShaderProgram)& theProgram,
1946                                                                Standard_Integer theBits,
1947                                                                Standard_Boolean theIsOutline)
1948 {
1949   Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
1950   TCollection_AsciiString aSrcVert, aSrcVertExtraMain, aSrcVertExtraFunc, aSrcGetAlpha, aSrcVertEndMain;
1951   TCollection_AsciiString aSrcFrag, aSrcFragExtraMain;
1952   TCollection_AsciiString aSrcFragGetColor     = EOL"vec4 getColor(void) { return occColor; }";
1953   TCollection_AsciiString aSrcFragMainGetColor = EOL"  occSetFragColor (getFinalColor());";
1954   OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
1955
1956   if ((theBits & OpenGl_PO_IsPoint) != 0)
1957   {
1958   #if defined(GL_ES_VERSION_2_0)
1959     aSrcVertExtraMain += EOL"  gl_PointSize = occPointSize;";
1960   #endif
1961
1962     if ((theBits & OpenGl_PO_PointSprite) != 0)
1963     {
1964       aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D occSamplerPointSprite", Graphic3d_TOS_FRAGMENT));
1965       if ((theBits & OpenGl_PO_PointSpriteA) != OpenGl_PO_PointSpriteA)
1966       {
1967         aSrcFragGetColor =
1968           EOL"vec4 getColor(void) { return occTexture2D(occSamplerPointSprite, " THE_VEC2_glPointCoord "); }";
1969       }
1970       else if ((theBits & OpenGl_PO_TextureRGB) != 0
1971             && (theBits & OpenGl_PO_VertColor) == 0)
1972       {
1973         aProgramSrc->SetTextureSetBits (Graphic3d_TextureSetBits_BaseColor);
1974         aUniforms   .Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D occSamplerBaseColor", Graphic3d_TOS_VERTEX));
1975         aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 VertColor", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
1976         aSrcVertExtraMain +=
1977           EOL"  VertColor = occTexture2D (occSamplerBaseColor, occTexCoord.xy);";
1978         aSrcFragGetColor =
1979           EOL"vec4 getColor(void) { return VertColor; }";
1980       }
1981
1982       aSrcGetAlpha = pointSpriteAlphaSrc (theBits);
1983
1984     #if !defined(GL_ES_VERSION_2_0)
1985       if (myContext->core11 != NULL
1986         && myContext->IsGlGreaterEqual (2, 1))
1987       {
1988         aProgramSrc->SetHeader ("#version 120"); // gl_PointCoord has been added since GLSL 1.2
1989       }
1990     #endif
1991
1992       aSrcFragMainGetColor =
1993         EOL"  vec4 aColor = getColor();"
1994         EOL"  aColor.a = getAlpha();"
1995         EOL"  if (aColor.a <= 0.1) discard;"
1996         EOL"  occSetFragColor (aColor);";
1997     }
1998     else
1999     {
2000       if ((theBits & OpenGl_PO_TextureRGB) != 0
2001        && (theBits & OpenGl_PO_VertColor) == 0)
2002       {
2003         aProgramSrc->SetTextureSetBits (Graphic3d_TextureSetBits_BaseColor);
2004         aUniforms   .Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D occSamplerBaseColor", Graphic3d_TOS_VERTEX));
2005         aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 VertColor", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2006         aSrcVertExtraMain +=
2007           EOL"  VertColor = occTexture2D (occSamplerBaseColor, occTexCoord.xy);";
2008         aSrcFragGetColor =
2009           EOL"vec4 getColor(void) { return VertColor; }";
2010       }
2011
2012       aSrcFragMainGetColor =
2013         EOL"  vec4 aColor = getColor();"
2014         EOL"  if (aColor.a <= 0.1) discard;"
2015         EOL"  occSetFragColor (aColor);";
2016     }
2017   }
2018   else
2019   {
2020     if ((theBits & OpenGl_PO_HasTextures) != 0)
2021     {
2022       aUniforms   .Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D occSamplerBaseColor", Graphic3d_TOS_FRAGMENT));
2023       aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 TexCoord", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2024
2025       if ((theBits & OpenGl_PO_HasTextures) == OpenGl_PO_TextureEnv)
2026       {
2027         aSrcVertExtraFunc = THE_FUNC_transformNormal_view;
2028
2029         aSrcVertExtraMain +=
2030           EOL"  vec4 aPosition = occWorldViewMatrix * occModelWorldMatrix * occVertex;"
2031           EOL"  vec3 aNormal   = transformNormal (occNormal);"
2032           EOL"  vec3 aReflect  = reflect (normalize (aPosition.xyz), aNormal);"
2033           EOL"  aReflect.z += 1.0;"
2034           EOL"  TexCoord = vec4(aReflect.xy * inversesqrt (dot (aReflect, aReflect)) * 0.5 + vec2 (0.5), 0.0, 1.0);";
2035
2036         aSrcFragGetColor =
2037           EOL"vec4 getColor(void) { return occTexture2D (occSamplerBaseColor, TexCoord.st); }";
2038       }
2039       else
2040       {
2041         aProgramSrc->SetTextureSetBits (Graphic3d_TextureSetBits_BaseColor);
2042         aSrcVertExtraMain += THE_VARY_TexCoord_Trsf;
2043
2044         aSrcFragGetColor =
2045           EOL"vec4 getColor(void) { return occTexture2D(occSamplerBaseColor, TexCoord.st / TexCoord.w); }";
2046       }
2047     }
2048   }
2049   if ((theBits & OpenGl_PO_VertColor) != 0)
2050   {
2051     aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 VertColor", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2052     aSrcVertExtraMain += EOL"  VertColor = occVertColor;";
2053     aSrcFragGetColor  =  EOL"vec4 getColor(void) { return VertColor; }";
2054   }
2055
2056   int aNbClipPlanes = 0;
2057   if ((theBits & OpenGl_PO_ClipPlanesN) != 0)
2058   {
2059     aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 PositionWorld", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2060     aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 Position",      Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2061     aSrcVertExtraMain +=
2062       EOL"  PositionWorld = occModelWorldMatrix * occVertex;"
2063       EOL"  Position      = occWorldViewMatrix * PositionWorld;";
2064
2065     if ((theBits & OpenGl_PO_ClipPlanesN) == OpenGl_PO_ClipPlanesN)
2066     {
2067       aNbClipPlanes = Graphic3d_ShaderProgram::THE_MAX_CLIP_PLANES_DEFAULT;
2068       aSrcFragExtraMain += (theBits & OpenGl_PO_ClipChains) != 0
2069                          ? THE_FRAG_CLIP_CHAINS_N
2070                          : THE_FRAG_CLIP_PLANES_N;
2071     }
2072     else if ((theBits & OpenGl_PO_ClipPlanes1) != 0)
2073     {
2074       aNbClipPlanes = 1;
2075       aSrcFragExtraMain += THE_FRAG_CLIP_PLANES_1;
2076     }
2077     else if ((theBits & OpenGl_PO_ClipPlanes2) != 0)
2078     {
2079       aNbClipPlanes = 2;
2080       aSrcFragExtraMain += (theBits & OpenGl_PO_ClipChains) != 0
2081                          ? THE_FRAG_CLIP_CHAINS_2
2082                          : THE_FRAG_CLIP_PLANES_2;
2083     }
2084   }
2085   if ((theBits & OpenGl_PO_WriteOit) != 0)
2086   {
2087     aProgramSrc->SetNbFragmentOutputs (2);
2088     aProgramSrc->SetWeightOitOutput (true);
2089   }
2090
2091   if (theIsOutline)
2092   {
2093     aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("float occOrthoScale",          Graphic3d_TOS_VERTEX));
2094     aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("float occSilhouetteThickness", Graphic3d_TOS_VERTEX));
2095     aSrcVertEndMain = THE_VERT_gl_Position_OUTLINE;
2096   }
2097   else if ((theBits & OpenGl_PO_StippleLine) != 0)
2098   {
2099     const Standard_Integer aBits = defaultGlslVersion (aProgramSrc, "unlit", theBits);
2100     if ((aBits & OpenGl_PO_StippleLine) != 0)
2101     {
2102       if (myContext->hasGlslBitwiseOps != OpenGl_FeatureNotAvailable)
2103       {
2104         aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("int   occStipplePattern", Graphic3d_TOS_FRAGMENT));
2105       }
2106       else
2107       {
2108         aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("bool  occStipplePattern[16]", Graphic3d_TOS_FRAGMENT));
2109       }
2110       aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("float occStippleFactor",  Graphic3d_TOS_FRAGMENT));
2111       aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 occViewport", Graphic3d_TOS_VERTEX));
2112       aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec2 ScreenSpaceCoord", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2113       aSrcVertEndMain =
2114         EOL"  vec2 aPosition   = gl_Position.xy / gl_Position.w;"
2115         EOL"  aPosition        = aPosition * 0.5 + 0.5;"
2116         EOL"  ScreenSpaceCoord = aPosition.xy * occViewport.zw + occViewport.xy;";
2117       aSrcFragMainGetColor = TCollection_AsciiString()
2118       + EOL"  vec2 anAxis = vec2 (0.0, 1.0);"
2119         EOL"  if (abs (dFdx (ScreenSpaceCoord.x)) - abs (dFdy (ScreenSpaceCoord.y)) > 0.001)" 
2120         EOL"  {"
2121         EOL"    anAxis = vec2 (1.0, 0.0);"
2122         EOL"  }"
2123         EOL"  float aRotatePoint = dot (gl_FragCoord.xy, anAxis);"
2124       + (myContext->hasGlslBitwiseOps != OpenGl_FeatureNotAvailable
2125        ? EOL"  uint aBit = uint (floor (aRotatePoint / occStippleFactor + 0.5)) & 15U;"
2126          EOL"  if ((uint (occStipplePattern) & (1U << aBit)) == 0U) discard;"
2127        : EOL"  int aBit = int (mod (floor (aRotatePoint / occStippleFactor + 0.5), 16.0));"
2128          EOL"  if (!occStipplePattern[aBit]) discard;")
2129       + EOL"  vec4 aColor = getFinalColor();"
2130         EOL"  if (aColor.a <= 0.1) discard;"
2131         EOL"  occSetFragColor (aColor);";
2132     }
2133     else
2134     {
2135       myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_HIGH, "Warning: stipple lines in GLSL will be ignored.");
2136     }
2137   }
2138
2139   aSrcVert =
2140       aSrcVertExtraFunc
2141     + EOL"void main()"
2142       EOL"{"
2143     + aSrcVertExtraMain
2144     + THE_VERT_gl_Position
2145     + aSrcVertEndMain
2146     + EOL"}";
2147
2148   TCollection_AsciiString aSrcGeom = prepareGeomMainSrc (aUniforms, aStageInOuts, theBits);
2149   aSrcFragGetColor += (theBits & OpenGl_PO_MeshEdges) != 0
2150     ? THE_FRAG_WIREFRAME_COLOR
2151     : EOL"#define getFinalColor getColor";
2152
2153   aSrcFrag =
2154       aSrcFragGetColor
2155     + aSrcGetAlpha
2156     + EOL"void main()"
2157       EOL"{"
2158     + aSrcFragExtraMain
2159     + aSrcFragMainGetColor
2160     + EOL"}";
2161
2162   defaultGlslVersion (aProgramSrc, theIsOutline ? "outline" : "unlit", theBits);
2163   aProgramSrc->SetDefaultSampler (false);
2164   aProgramSrc->SetNbLightsMax (0);
2165   aProgramSrc->SetNbClipPlanesMax (aNbClipPlanes);
2166   aProgramSrc->SetAlphaTest ((theBits & OpenGl_PO_AlphaTest) != 0);
2167   const Standard_Integer aNbGeomInputVerts = !aSrcGeom.IsEmpty() ? 3 : 0;
2168   aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX,   aUniforms, aStageInOuts, "", "", aNbGeomInputVerts));
2169   aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcGeom, Graphic3d_TOS_GEOMETRY, aUniforms, aStageInOuts, "geomIn", "geomOut", aNbGeomInputVerts));
2170   aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts, "", "", aNbGeomInputVerts));
2171   TCollection_AsciiString aKey;
2172   if (!Create (aProgramSrc, aKey, theProgram))
2173   {
2174     theProgram = new OpenGl_ShaderProgram(); // just mark as invalid
2175     return Standard_False;
2176   }
2177   return Standard_True;
2178 }
2179
2180 // =======================================================================
2181 // function : pointSpriteShadingSrc
2182 // purpose  :
2183 // =======================================================================
2184 TCollection_AsciiString OpenGl_ShaderManager::pointSpriteShadingSrc (const TCollection_AsciiString& theBaseColorSrc,
2185                                                                      Standard_Integer theBits)
2186 {
2187   TCollection_AsciiString aSrcFragGetColor;
2188   if ((theBits & OpenGl_PO_PointSpriteA) == OpenGl_PO_PointSpriteA)
2189   {
2190     aSrcFragGetColor = pointSpriteAlphaSrc (theBits) +
2191       EOL"vec4 getColor(void)"
2192       EOL"{"
2193       EOL"  vec4 aColor = " + theBaseColorSrc + ";"
2194       EOL"  aColor.a = getAlpha();"
2195       EOL"  if (aColor.a <= 0.1) discard;"
2196       EOL"  return aColor;"
2197       EOL"}";
2198   }
2199   else if ((theBits & OpenGl_PO_PointSprite) == OpenGl_PO_PointSprite)
2200   {
2201     aSrcFragGetColor = TCollection_AsciiString() +
2202       EOL"vec4 getColor(void)"
2203       EOL"{"
2204       EOL"  vec4 aColor = " + theBaseColorSrc + ";"
2205       EOL"  aColor = occTexture2D(occSamplerPointSprite, " THE_VEC2_glPointCoord ") * aColor;"
2206       EOL"  if (aColor.a <= 0.1) discard;"
2207       EOL"  return aColor;"
2208       EOL"}";
2209   }
2210
2211   return aSrcFragGetColor;
2212 }
2213
2214 // =======================================================================
2215 // function : stdComputeLighting
2216 // purpose  :
2217 // =======================================================================
2218 TCollection_AsciiString OpenGl_ShaderManager::stdComputeLighting (Standard_Integer& theNbLights,
2219                                                                   Standard_Boolean  theHasVertColor,
2220                                                                   Standard_Boolean  theIsPBR,
2221                                                                   Standard_Boolean  theHasEmissive)
2222 {
2223   TCollection_AsciiString aLightsFunc, aLightsLoop;
2224   theNbLights = 0;
2225   const Handle(Graphic3d_LightSet)& aLights = myLightSourceState.LightSources();
2226   if (!aLights.IsNull())
2227   {
2228     theNbLights = aLights->NbEnabled();
2229     if (theNbLights <= THE_NB_UNROLLED_LIGHTS_MAX)
2230     {
2231       Standard_Integer anIndex = 0;
2232       for (Graphic3d_LightSet::Iterator aLightIter (aLights, Graphic3d_LightSet::IterationFilter_ExcludeDisabledAndAmbient);
2233            aLightIter.More(); aLightIter.Next(), ++anIndex)
2234       {
2235         switch (aLightIter.Value()->Type())
2236         {
2237           case Graphic3d_TOLS_AMBIENT:
2238             --anIndex;
2239             break; // skip ambient
2240           case Graphic3d_TOLS_DIRECTIONAL:
2241             aLightsLoop = aLightsLoop + EOL"    directionalLight (" + anIndex + ", theNormal, theView, theIsFront);";
2242             break;
2243           case Graphic3d_TOLS_POSITIONAL:
2244             aLightsLoop = aLightsLoop + EOL"    pointLight (" + anIndex + ", theNormal, theView, aPoint, theIsFront);";
2245             break;
2246           case Graphic3d_TOLS_SPOT:
2247             aLightsLoop = aLightsLoop + EOL"    spotLight (" + anIndex + ", theNormal, theView, aPoint, theIsFront);";
2248             break;
2249         }
2250       }
2251     }
2252     else
2253     {
2254       theNbLights = roundUpMaxLightSources (theNbLights);
2255       bool isFirstInLoop = true;
2256       aLightsLoop = aLightsLoop +
2257         EOL"    for (int anIndex = 0; anIndex < occLightSourcesCount; ++anIndex)"
2258         EOL"    {"
2259         EOL"      int aType = occLight_Type (anIndex);";
2260       if (aLights->NbEnabledLightsOfType (Graphic3d_TOLS_DIRECTIONAL) > 0)
2261       {
2262         isFirstInLoop = false;
2263         aLightsLoop +=
2264           EOL"      if (aType == OccLightType_Direct)"
2265           EOL"      {"
2266           EOL"        directionalLight (anIndex, theNormal, theView, theIsFront);"
2267           EOL"      }";
2268       }
2269       if (aLights->NbEnabledLightsOfType (Graphic3d_TOLS_POSITIONAL) > 0)
2270       {
2271         if (!isFirstInLoop)
2272         {
2273           aLightsLoop += EOL"      else ";
2274         }
2275         isFirstInLoop = false;
2276         aLightsLoop +=
2277           EOL"      if (aType == OccLightType_Point)"
2278           EOL"      {"
2279           EOL"        pointLight (anIndex, theNormal, theView, aPoint, theIsFront);"
2280           EOL"      }";
2281       }
2282       if (aLights->NbEnabledLightsOfType (Graphic3d_TOLS_SPOT) > 0)
2283       {
2284         if (!isFirstInLoop)
2285         {
2286           aLightsLoop += EOL"      else ";
2287         }
2288         isFirstInLoop = false;
2289         aLightsLoop +=
2290           EOL"      if (aType == OccLightType_Spot)"
2291           EOL"      {"
2292           EOL"        spotLight (anIndex, theNormal, theView, aPoint, theIsFront);"
2293           EOL"      }";
2294       }
2295       aLightsLoop += EOL"    }";
2296     }
2297
2298     if (theIsPBR)
2299     {
2300       aLightsFunc += Shaders_PBRDistribution_glsl;
2301       aLightsFunc += Shaders_PBRGeometry_glsl;
2302       aLightsFunc += Shaders_PBRFresnel_glsl;
2303       aLightsFunc += Shaders_PBRCookTorrance_glsl;
2304       aLightsFunc += Shaders_PBRIllumination_glsl;
2305     }
2306
2307     if (aLights->NbEnabledLightsOfType (Graphic3d_TOLS_DIRECTIONAL) == 1
2308      && theNbLights == 1
2309      && !theIsPBR)
2310     {
2311       // use the version with hard-coded first index
2312       aLightsLoop = EOL"    directionalLightFirst(theNormal, theView, theIsFront);";
2313       aLightsFunc += THE_FUNC_directionalLightFirst;
2314     }
2315     else if (aLights->NbEnabledLightsOfType (Graphic3d_TOLS_DIRECTIONAL) > 0)
2316     {
2317       aLightsFunc += theIsPBR ? THE_FUNC_PBR_directionalLight : THE_FUNC_directionalLight;
2318     }
2319     if (aLights->NbEnabledLightsOfType (Graphic3d_TOLS_POSITIONAL) > 0)
2320     {
2321       aLightsFunc += theIsPBR ? THE_FUNC_PBR_pointLight : THE_FUNC_pointLight;
2322     }
2323     if (aLights->NbEnabledLightsOfType (Graphic3d_TOLS_SPOT) > 0)
2324     {
2325       aLightsFunc += theIsPBR ? THE_FUNC_PBR_spotLight : THE_FUNC_spotLight;
2326     }
2327   }
2328
2329   TCollection_AsciiString aGetMatAmbient = "theIsFront ? occFrontMaterial_Ambient()  : occBackMaterial_Ambient();";
2330   TCollection_AsciiString aGetMatDiffuse = "theIsFront ? occFrontMaterial_Diffuse()  : occBackMaterial_Diffuse();";
2331   if (theHasVertColor)
2332   {
2333     aGetMatAmbient = "getVertColor();";
2334     aGetMatDiffuse = "getVertColor();";
2335   }
2336
2337   if (!theIsPBR)
2338   {
2339     return TCollection_AsciiString()
2340     + THE_FUNC_lightDef
2341     + Shaders_PointLightAttenuation_glsl
2342     + aLightsFunc
2343     + EOL
2344       EOL"vec4 computeLighting (in vec3 theNormal,"
2345       EOL"                      in vec3 theView,"
2346       EOL"                      in vec4 thePoint,"
2347       EOL"                      in bool theIsFront)"
2348       EOL"{"
2349       EOL"  Ambient  = occLightAmbient.rgb;"
2350       EOL"  Diffuse  = vec3 (0.0);"
2351       EOL"  Specular = vec3 (0.0);"
2352       EOL"  vec3 aPoint = thePoint.xyz / thePoint.w;"
2353     + aLightsLoop
2354     + EOL"  vec4 aMatAmbient  = " + aGetMatAmbient
2355     + EOL"  vec4 aMatDiffuse  = " + aGetMatDiffuse
2356     + EOL"  vec4 aMatSpecular = theIsFront ? occFrontMaterial_Specular() : occBackMaterial_Specular();"
2357       EOL"  vec3 aColor = Ambient * aMatAmbient.rgb + Diffuse * aMatDiffuse.rgb + Specular * aMatSpecular.rgb;"
2358       EOL"  occTextureOcclusion(aColor, TexCoord.st);"
2359     + (theHasEmissive
2360     ? EOL"  vec4 aMatEmission = theIsFront ? occFrontMaterial_Emission() : occBackMaterial_Emission();"
2361       EOL"  aColor += aMatEmission.rgb;" : "")
2362     + EOL"  return vec4 (aColor, aMatDiffuse.a);"
2363       EOL"}";
2364   }
2365   else
2366   {
2367     return TCollection_AsciiString()
2368     + THE_FUNC_PBR_lightDef
2369     + Shaders_PointLightAttenuation_glsl
2370     + aLightsFunc
2371     + EOL
2372       EOL"vec4 computeLighting (in vec3 theNormal,"
2373       EOL"                      in vec3 theView,"
2374       EOL"                      in vec4 thePoint,"
2375       EOL"                      in bool theIsFront)"
2376       EOL"{"
2377       EOL"  DirectLighting = vec3(0.0);"
2378       EOL"  BaseColor = " + (theHasVertColor ? "getVertColor();" : "occTextureColor(occPBRMaterial_Color (theIsFront), TexCoord.st / TexCoord.w);")
2379     + EOL"  Emission            = occTextureEmissive(occPBRMaterial_Emission (theIsFront), TexCoord.st / TexCoord.w);"
2380       EOL"  Metallic            = occTextureMetallic(occPBRMaterial_Metallic (theIsFront), TexCoord.st / TexCoord.w);"
2381       EOL"  NormalizedRoughness = occTextureRoughness(occPBRMaterial_NormalizedRoughness (theIsFront), TexCoord.st / TexCoord.w);"
2382       EOL"  Roughness = occRoughness (NormalizedRoughness);"
2383       EOL"  IOR       = occPBRMaterial_IOR (theIsFront);"
2384       EOL"  vec3 aPoint = thePoint.xyz / thePoint.w;"
2385     + aLightsLoop
2386     + EOL"  vec3 aColor = DirectLighting;"
2387       EOL"  vec3 anIndirectLightingSpec = occPBRFresnel (BaseColor.rgb, Metallic, IOR);"
2388       EOL"  vec2 aCoeff = occTexture2D (occEnvLUT, vec2(abs(dot(theView, theNormal)), NormalizedRoughness)).xy;"
2389       EOL"  anIndirectLightingSpec *= aCoeff.x;"
2390       EOL"  anIndirectLightingSpec += aCoeff.y;"
2391       EOL"  anIndirectLightingSpec *= occTextureCubeLod (occSpecIBLMap, -reflect (theView, theNormal), NormalizedRoughness * float (occNbSpecIBLLevels - 1)).rgb;"
2392       EOL"  vec3 aRefractionCoeff = 1.0 - occPBRFresnel (BaseColor.rgb, Metallic, NormalizedRoughness, IOR, abs(dot(theView, theNormal)));"
2393       EOL"  aRefractionCoeff *= (1.0 - Metallic);"
2394       EOL"  vec3 anIndirectLightingDiff = aRefractionCoeff * BaseColor.rgb * BaseColor.a;"
2395       EOL"  anIndirectLightingDiff *= occDiffIBLMap (theNormal).rgb;"
2396       EOL"  aColor += occLightAmbient.rgb * (anIndirectLightingDiff + anIndirectLightingSpec);"
2397       EOL"  aColor += Emission;"
2398       EOL"  occTextureOcclusion(aColor, TexCoord.st / TexCoord.w);"
2399       EOL"  return vec4 (aColor, mix(1.0, BaseColor.a, aRefractionCoeff.x));"
2400       EOL"}";
2401   }
2402 }
2403
2404 // =======================================================================
2405 // function : prepareStdProgramGouraud
2406 // purpose  :
2407 // =======================================================================
2408 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramGouraud (Handle(OpenGl_ShaderProgram)& theProgram,
2409                                                                  const Standard_Integer        theBits)
2410 {
2411   Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
2412   TCollection_AsciiString aSrcVert, aSrcVertColor, aSrcVertExtraMain;
2413   TCollection_AsciiString aSrcFrag, aSrcFragExtraMain;
2414   TCollection_AsciiString aSrcFragGetColor = EOL"vec4 getColor(void) { return gl_FrontFacing ? FrontColor : BackColor; }";
2415   OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
2416
2417   if ((theBits & OpenGl_PO_IsPoint) != 0)
2418   {
2419   #if defined(GL_ES_VERSION_2_0)
2420     aSrcVertExtraMain += EOL"  gl_PointSize = occPointSize;";
2421   #endif
2422
2423     if ((theBits & OpenGl_PO_PointSprite) != 0)
2424     {
2425     #if !defined(GL_ES_VERSION_2_0)
2426       if (myContext->core11 != NULL
2427         && myContext->IsGlGreaterEqual (2, 1))
2428       {
2429         aProgramSrc->SetHeader ("#version 120"); // gl_PointCoord has been added since GLSL 1.2
2430       }
2431     #endif
2432
2433       aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D occSamplerPointSprite", Graphic3d_TOS_FRAGMENT));
2434       aSrcFragGetColor = pointSpriteShadingSrc ("gl_FrontFacing ? FrontColor : BackColor", theBits);
2435     }
2436
2437     if ((theBits & OpenGl_PO_TextureRGB) != 0
2438      && (theBits & OpenGl_PO_VertColor) == 0)
2439     {
2440       aProgramSrc->SetTextureSetBits (Graphic3d_TextureSetBits_BaseColor);
2441       aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D occSamplerBaseColor", Graphic3d_TOS_VERTEX));
2442       aSrcVertColor = EOL"vec4 getVertColor(void) { return occTexture2D (occSamplerBaseColor, occTexCoord.xy); }";
2443     }
2444   }
2445   else
2446   {
2447     if ((theBits & OpenGl_PO_TextureRGB) != 0)
2448     {
2449       aProgramSrc->SetTextureSetBits (Graphic3d_TextureSetBits_BaseColor);
2450       aUniforms   .Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D occSamplerBaseColor", Graphic3d_TOS_FRAGMENT));
2451       aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 TexCoord", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2452       aSrcVertExtraMain += THE_VARY_TexCoord_Trsf;
2453
2454       aSrcFragGetColor =
2455         EOL"vec4 getColor(void)"
2456         EOL"{"
2457         EOL"  vec4 aColor = gl_FrontFacing ? FrontColor : BackColor;"
2458         EOL"  return occTexture2D(occSamplerBaseColor, TexCoord.st / TexCoord.w) * aColor;"
2459         EOL"}";
2460     }
2461   }
2462
2463   if ((theBits & OpenGl_PO_VertColor) != 0)
2464   {
2465     aSrcVertColor = EOL"vec4 getVertColor(void) { return occVertColor; }";
2466   }
2467
2468   int aNbClipPlanes = 0;
2469   if ((theBits & OpenGl_PO_ClipPlanesN) != 0)
2470   {
2471     aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 PositionWorld", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2472     aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 Position",      Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2473     aSrcVertExtraMain +=
2474       EOL"  PositionWorld = aPositionWorld;"
2475       EOL"  Position      = aPosition;";
2476
2477     if ((theBits & OpenGl_PO_ClipPlanesN) == OpenGl_PO_ClipPlanesN)
2478     {
2479       aNbClipPlanes = Graphic3d_ShaderProgram::THE_MAX_CLIP_PLANES_DEFAULT;
2480       aSrcFragExtraMain += (theBits & OpenGl_PO_ClipChains) != 0
2481                          ? THE_FRAG_CLIP_CHAINS_N
2482                          : THE_FRAG_CLIP_PLANES_N;
2483     }
2484     else if ((theBits & OpenGl_PO_ClipPlanes1) != 0)
2485     {
2486       aNbClipPlanes = 1;
2487       aSrcFragExtraMain += THE_FRAG_CLIP_PLANES_1;
2488     }
2489     else if ((theBits & OpenGl_PO_ClipPlanes2) != 0)
2490     {
2491       aNbClipPlanes = 2;
2492       aSrcFragExtraMain += (theBits & OpenGl_PO_ClipChains) != 0
2493                           ? THE_FRAG_CLIP_CHAINS_2
2494                           : THE_FRAG_CLIP_PLANES_2;
2495     }
2496   }
2497   if ((theBits & OpenGl_PO_WriteOit) != 0)
2498   {
2499     aProgramSrc->SetNbFragmentOutputs (2);
2500     aProgramSrc->SetWeightOitOutput (true);
2501   }
2502
2503   aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 FrontColor", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2504   aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 BackColor",  Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2505
2506   Standard_Integer aNbLights = 0;
2507   const TCollection_AsciiString aLights = stdComputeLighting (aNbLights, !aSrcVertColor.IsEmpty(), false, true);
2508   aSrcVert = TCollection_AsciiString()
2509     + THE_FUNC_transformNormal_view
2510     + EOL
2511     + aSrcVertColor
2512     + aLights
2513     + EOL"void main()"
2514       EOL"{"
2515       EOL"  vec4 aPositionWorld = occModelWorldMatrix * occVertex;"
2516       EOL"  vec4 aPosition      = occWorldViewMatrix * aPositionWorld;"
2517       EOL"  vec3 aNormal        = transformNormal (occNormal);"
2518       EOL"  vec3 aView          = vec3 (0.0, 0.0, 1.0);"
2519       EOL"  FrontColor  = computeLighting (normalize (aNormal), normalize (aView), aPosition, true);"
2520       EOL"  BackColor   = computeLighting (normalize (aNormal), normalize (aView), aPosition, false);"
2521     + aSrcVertExtraMain
2522     + THE_VERT_gl_Position
2523     + EOL"}";
2524
2525   TCollection_AsciiString aSrcGeom = prepareGeomMainSrc (aUniforms, aStageInOuts, theBits);
2526   aSrcFragGetColor += (theBits & OpenGl_PO_MeshEdges) != 0
2527     ? THE_FRAG_WIREFRAME_COLOR
2528     : EOL"#define getFinalColor getColor";
2529
2530   aSrcFrag = TCollection_AsciiString()
2531     + aSrcFragGetColor
2532     + EOL"void main()"
2533       EOL"{"
2534     + aSrcFragExtraMain
2535     + EOL"  occSetFragColor (getFinalColor());"
2536     + EOL"}";
2537
2538   const TCollection_AsciiString aProgId = TCollection_AsciiString ("gouraud-") + genLightKey (myLightSourceState.LightSources()) + "-";
2539   defaultGlslVersion (aProgramSrc, aProgId, theBits);
2540   aProgramSrc->SetDefaultSampler (false);
2541   aProgramSrc->SetNbLightsMax (aNbLights);
2542   aProgramSrc->SetNbClipPlanesMax (aNbClipPlanes);
2543   aProgramSrc->SetAlphaTest ((theBits & OpenGl_PO_AlphaTest) != 0);
2544   const Standard_Integer aNbGeomInputVerts = !aSrcGeom.IsEmpty() ? 3 : 0;
2545   aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX,   aUniforms, aStageInOuts, "", "", aNbGeomInputVerts));
2546   aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcGeom, Graphic3d_TOS_GEOMETRY, aUniforms, aStageInOuts, "geomIn", "geomOut", aNbGeomInputVerts));
2547   aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts, "", "", aNbGeomInputVerts));
2548   TCollection_AsciiString aKey;
2549   if (!Create (aProgramSrc, aKey, theProgram))
2550   {
2551     theProgram = new OpenGl_ShaderProgram(); // just mark as invalid
2552     return Standard_False;
2553   }
2554   return Standard_True;
2555 }
2556
2557 // =======================================================================
2558 // function : prepareStdProgramPhong
2559 // purpose  :
2560 // =======================================================================
2561 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramPhong (Handle(OpenGl_ShaderProgram)& theProgram,
2562                                                                const Standard_Integer        theBits,
2563                                                                const Standard_Boolean        theIsFlatNormal,
2564                                                                const Standard_Boolean        theIsPBR)
2565 {
2566   TCollection_AsciiString aPosition = theIsPBR ? "PositionWorld" : "Position";
2567   TCollection_AsciiString aPhongCompLight = TCollection_AsciiString() +
2568     "computeLighting (normalize (Normal), normalize (View), " + aPosition + ", gl_FrontFacing)";
2569   const bool isFlatNormal = theIsFlatNormal
2570                          && myContext->hasFlatShading != OpenGl_FeatureNotAvailable;
2571   const char* aDFdxSignReversion = "";
2572 #if defined(GL_ES_VERSION_2_0)
2573   if (isFlatNormal != theIsFlatNormal)
2574   {
2575     myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION,
2576                             GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_MEDIUM,
2577                             "Warning: flat shading requires OpenGL ES 3.0+ or GL_OES_standard_derivatives extension.");
2578   }
2579   else if (isFlatNormal
2580         && myContext->Vendor().Search("qualcomm") != -1)
2581   {
2582     // workaround Adreno driver bug computing reversed normal using dFdx/dFdy
2583     aDFdxSignReversion = "-";
2584     myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_MEDIUM,
2585                             "Warning: applied workaround for flat shading normal computation using dFdx/dFdy on Adreno");
2586   }
2587 #endif
2588   Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
2589   aProgramSrc->SetPBR (theIsPBR);
2590
2591   TCollection_AsciiString aSrcVert, aSrcVertExtraFunc, aSrcVertExtraMain;
2592   TCollection_AsciiString aSrcFrag, aSrcFragGetVertColor, aSrcFragExtraMain;
2593   TCollection_AsciiString aSrcFragGetColor = TCollection_AsciiString() + EOL"vec4 getColor(void) { return " + aPhongCompLight +  "; }";
2594   OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
2595   if ((theBits & OpenGl_PO_IsPoint) != 0)
2596   {
2597   #if defined(GL_ES_VERSION_2_0)
2598     aSrcVertExtraMain += EOL"  gl_PointSize = occPointSize;";
2599   #endif
2600
2601     if ((theBits & OpenGl_PO_PointSprite) != 0)
2602     {
2603     #if !defined(GL_ES_VERSION_2_0)
2604       if (myContext->core11 != NULL
2605         && myContext->IsGlGreaterEqual (2, 1))
2606       {
2607         aProgramSrc->SetHeader ("#version 120"); // gl_PointCoord has been added since GLSL 1.2
2608       }
2609     #endif
2610
2611       aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D occSamplerPointSprite", Graphic3d_TOS_FRAGMENT));
2612       aSrcFragGetColor = pointSpriteShadingSrc (aPhongCompLight, theBits);
2613     }
2614
2615     if ((theBits & OpenGl_PO_TextureRGB) != 0
2616      && (theBits & OpenGl_PO_VertColor) == 0)
2617     {
2618       aProgramSrc->SetTextureSetBits (Graphic3d_TextureSetBits_BaseColor);
2619       aUniforms   .Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D occSamplerBaseColor", Graphic3d_TOS_VERTEX));
2620       aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 VertColor", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2621
2622       aSrcVertExtraMain   += EOL"  VertColor = occTexture2D (occSamplerBaseColor, occTexCoord.xy);";
2623       aSrcFragGetVertColor = EOL"vec4 getVertColor(void) { return VertColor; }";
2624     }
2625   }
2626   else
2627   {
2628     if ((theBits & OpenGl_PO_TextureRGB) != 0)
2629     {
2630       aUniforms   .Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D occSamplerBaseColor", Graphic3d_TOS_FRAGMENT));
2631       aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 TexCoord", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2632       aSrcVertExtraMain += THE_VARY_TexCoord_Trsf;
2633
2634       Standard_Integer aTextureBits = Graphic3d_TextureSetBits_BaseColor | Graphic3d_TextureSetBits_Occlusion | Graphic3d_TextureSetBits_Emissive;
2635       if (!theIsPBR)
2636       {
2637         aSrcFragGetColor = TCollection_AsciiString() +
2638           EOL"vec4 getColor(void)"
2639           EOL"{"
2640           EOL"  vec2 aTexUV = TexCoord.st / TexCoord.w;"
2641           EOL"  vec4 aColor = " + aPhongCompLight + ";"
2642           EOL"  aColor *= occTexture2D(occSamplerBaseColor, aTexUV);"
2643           EOL"  vec3 anEmission = occTextureEmissive((gl_FrontFacing ? occFrontMaterial_Emission() : occBackMaterial_Emission()).rgb, aTexUV);"
2644           EOL"  aColor.rgb += anEmission;"
2645           EOL"  return aColor;"
2646           EOL"}";
2647       }
2648       else
2649       {
2650         aTextureBits |= Graphic3d_TextureSetBits_MetallicRoughness;
2651       }
2652       if ((theBits & OpenGl_PO_HasTextures) == OpenGl_PO_TextureNormal
2653        && !isFlatNormal)
2654       {
2655         if (myContext->hasFlatShading != OpenGl_FeatureNotAvailable)
2656         {
2657           aTextureBits |= Graphic3d_TextureSetBits_Normal;
2658         }
2659         else
2660         {
2661           myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_MEDIUM,
2662                                   "Warning: ignoring Normal Map texture due to hardware capabilities");
2663         }
2664       }
2665       aProgramSrc->SetTextureSetBits (aTextureBits);
2666     }
2667   }
2668
2669   if ((theBits & OpenGl_PO_VertColor) != 0)
2670   {
2671     aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 VertColor", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2672     aSrcVertExtraMain   += EOL"  VertColor = occVertColor;";
2673     aSrcFragGetVertColor = EOL"vec4 getVertColor(void) { return VertColor; }";
2674   }
2675
2676   int aNbClipPlanes = 0;
2677   if ((theBits & OpenGl_PO_ClipPlanesN) != 0)
2678   {
2679     if ((theBits & OpenGl_PO_ClipPlanesN) == OpenGl_PO_ClipPlanesN)
2680     {
2681       aNbClipPlanes = Graphic3d_ShaderProgram::THE_MAX_CLIP_PLANES_DEFAULT;
2682       aSrcFragExtraMain += (theBits & OpenGl_PO_ClipChains) != 0
2683                          ? THE_FRAG_CLIP_CHAINS_N
2684                          : THE_FRAG_CLIP_PLANES_N;
2685     }
2686     else if ((theBits & OpenGl_PO_ClipPlanes1) != 0)
2687     {
2688       aNbClipPlanes = 1;
2689       aSrcFragExtraMain += THE_FRAG_CLIP_PLANES_1;
2690     }
2691     else if ((theBits & OpenGl_PO_ClipPlanes2) != 0)
2692     {
2693       aNbClipPlanes = 2;
2694       aSrcFragExtraMain += (theBits & OpenGl_PO_ClipChains) != 0
2695                          ? THE_FRAG_CLIP_CHAINS_2
2696                          : THE_FRAG_CLIP_PLANES_2;
2697     }
2698   }
2699   if ((theBits & OpenGl_PO_WriteOit) != 0)
2700   {
2701     aProgramSrc->SetNbFragmentOutputs (2);
2702     aProgramSrc->SetWeightOitOutput (true);
2703   }
2704
2705   if (isFlatNormal)
2706   {
2707     aSrcFragExtraMain += TCollection_AsciiString()
2708       + EOL"  Normal = " + aDFdxSignReversion + "normalize (cross (dFdx (" + aPosition + ".xyz / " + aPosition + ".w), dFdy (" + aPosition + ".xyz / " + aPosition + ".w)));"
2709         EOL"  if (!gl_FrontFacing) { Normal = -Normal; }";
2710   }
2711   else
2712   {
2713     aStageInOuts.Append(OpenGl_ShaderObject::ShaderVariable("vec3 vNormal", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2714     aSrcVertExtraFunc += THE_FUNC_transformNormal_world;
2715     aSrcVertExtraMain += EOL"  vNormal = transformNormal (occNormal);";
2716     aSrcFragExtraMain += EOL"  Normal = vNormal;";
2717
2718     if ((theBits & OpenGl_PO_IsPoint) == 0
2719      && (theBits & OpenGl_PO_HasTextures) == OpenGl_PO_TextureNormal
2720      && myContext->hasFlatShading != OpenGl_FeatureNotAvailable)
2721     {
2722       // apply normal map texture
2723       aSrcFragExtraMain +=
2724         EOL"#if defined(THE_HAS_TEXTURE_NORMAL)"
2725         EOL"  vec2 aTexCoord = TexCoord.st / TexCoord.w;"
2726         EOL"  vec4 aMapNormalValue = occTextureNormal(aTexCoord);"
2727         EOL"  if (aMapNormalValue.w > 0.5)"
2728         EOL"  {"
2729         EOL"    aMapNormalValue.xyz = normalize (aMapNormalValue.xyz * 2.0 - vec3(1.0));"
2730         EOL"    mat2 aDeltaUVMatrix = mat2 (dFdx(aTexCoord), dFdy(aTexCoord));"
2731         EOL"    aDeltaUVMatrix = mat2 (aDeltaUVMatrix[1][1], -aDeltaUVMatrix[0][1], -aDeltaUVMatrix[1][0], aDeltaUVMatrix[0][0]);"
2732         EOL"    mat2x3 aDeltaVectorMatrix = mat2x3 (dFdx (PositionWorld.xyz), dFdy (PositionWorld.xyz));"
2733         EOL"    aDeltaVectorMatrix = aDeltaVectorMatrix * aDeltaUVMatrix;"
2734         EOL"    aDeltaVectorMatrix[0] = normalize(aDeltaVectorMatrix[0] - dot(Normal, aDeltaVectorMatrix[0]) * Normal);"
2735         EOL"    aDeltaVectorMatrix[1] = normalize(aDeltaVectorMatrix[1] - dot(Normal, aDeltaVectorMatrix[1]) * Normal);"
2736         EOL"    float aDirection = gl_FrontFacing ? 1.0 : -1.0;"
2737         EOL"    Normal = mat3 (aDirection * aDeltaVectorMatrix[0], aDirection * aDeltaVectorMatrix[1], Normal) * aMapNormalValue.xyz;"
2738         EOL"  }"
2739         EOL"#endif";
2740     }
2741     if (!theIsPBR)
2742     {
2743       aSrcFragExtraMain +=
2744         EOL"  Normal = normalize ((occWorldViewMatrixInverseTranspose * vec4 (Normal, 0.0)).xyz);";
2745     }
2746   }
2747
2748   aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 PositionWorld", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2749   aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec4 Position",      Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2750   aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec3 View",          Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2751
2752   aSrcVert = TCollection_AsciiString()
2753     + aSrcVertExtraFunc
2754     + EOL"void main()"
2755       EOL"{"
2756       EOL"  PositionWorld = occModelWorldMatrix * occVertex;"
2757       EOL"  Position      = occWorldViewMatrix * PositionWorld;"
2758       EOL"  if (occProjectionMatrix[3][3] == 1.0)"
2759       EOL"  {"
2760       EOL"    View = vec3(0.0, 0.0, 1.0);"
2761       EOL"  }"
2762       EOL"  else"
2763       EOL"  {"
2764       EOL"    View = -Position.xyz;"
2765       EOL"  }"
2766     + (theIsPBR ? EOL"  View = (occWorldViewMatrixInverse * vec4(View, 0.0)).xyz;" : "")
2767     + aSrcVertExtraMain
2768     + THE_VERT_gl_Position
2769     + EOL"}";
2770
2771   TCollection_AsciiString aSrcGeom = prepareGeomMainSrc (aUniforms, aStageInOuts, theBits);
2772   aSrcFragGetColor += (theBits & OpenGl_PO_MeshEdges) != 0
2773     ? THE_FRAG_WIREFRAME_COLOR
2774     : EOL"#define getFinalColor getColor";
2775
2776   Standard_Integer aNbLights = 0;
2777   const TCollection_AsciiString aLights = stdComputeLighting (aNbLights, !aSrcFragGetVertColor.IsEmpty(), theIsPBR,
2778                                                               (theBits & OpenGl_PO_TextureRGB) == 0
2779                                                            || (theBits & OpenGl_PO_IsPoint) != 0);
2780   aSrcFrag = TCollection_AsciiString()
2781     + EOL
2782     + aSrcFragGetVertColor
2783     + EOL"vec3  Normal;"
2784     + aLights
2785     + aSrcFragGetColor
2786     + EOL
2787       EOL"void main()"
2788       EOL"{"
2789     + aSrcFragExtraMain
2790     + EOL"  occSetFragColor (getFinalColor());"
2791     + EOL"}";
2792
2793   const TCollection_AsciiString aProgId = TCollection_AsciiString (theIsFlatNormal ? "flat-" : "phong-") + (theIsPBR ? "pbr-" : "") + genLightKey (myLightSourceState.LightSources()) + "-";
2794   defaultGlslVersion (aProgramSrc, aProgId, theBits, isFlatNormal);
2795   aProgramSrc->SetDefaultSampler (false);
2796   aProgramSrc->SetNbLightsMax (aNbLights);
2797   aProgramSrc->SetNbClipPlanesMax (aNbClipPlanes);
2798   aProgramSrc->SetAlphaTest ((theBits & OpenGl_PO_AlphaTest) != 0);
2799
2800   const Standard_Integer aNbGeomInputVerts = !aSrcGeom.IsEmpty() ? 3 : 0;
2801   aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX,   aUniforms, aStageInOuts, "", "", aNbGeomInputVerts));
2802   aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcGeom, Graphic3d_TOS_GEOMETRY, aUniforms, aStageInOuts, "geomIn", "geomOut", aNbGeomInputVerts));
2803   aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts, "", "", aNbGeomInputVerts));
2804   TCollection_AsciiString aKey;
2805   if (!Create (aProgramSrc, aKey, theProgram))
2806   {
2807     theProgram = new OpenGl_ShaderProgram(); // just mark as invalid
2808     return Standard_False;
2809   }
2810   return Standard_True;
2811 }
2812
2813 // =======================================================================
2814 // function : prepareStdProgramStereo
2815 // purpose  :
2816 // =======================================================================
2817 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramStereo (Handle(OpenGl_ShaderProgram)& theProgram,
2818                                                                 const Graphic3d_StereoMode    theStereoMode)
2819 {
2820   Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
2821   OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
2822
2823   aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable ("vec2 TexCoord", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
2824   TCollection_AsciiString aSrcVert =
2825       EOL"void main()"
2826       EOL"{"
2827       EOL"  TexCoord    = occVertex.zw;"
2828       EOL"  gl_Position = vec4(occVertex.x, occVertex.y, 0.0, 1.0);"
2829       EOL"}";
2830
2831   TCollection_AsciiString aSrcFrag;
2832   aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D uLeftSampler",  Graphic3d_TOS_FRAGMENT));
2833   aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("sampler2D uRightSampler", Graphic3d_TOS_FRAGMENT));
2834   const char* aName = "stereo";
2835   switch (theStereoMode)
2836   {
2837     case Graphic3d_StereoMode_Anaglyph:
2838     {
2839       aName = "anaglyph";
2840       aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("mat4 uMultL", Graphic3d_TOS_FRAGMENT));
2841       aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("mat4 uMultR", Graphic3d_TOS_FRAGMENT));
2842       const TCollection_AsciiString aNormalize = mySRgbState
2843                                                ? EOL"#define sRgb2linear(theColor) theColor"
2844                                                  EOL"#define linear2sRgb(theColor) theColor"
2845                                                : EOL"#define sRgb2linear(theColor) pow(theColor, vec4(2.2, 2.2, 2.2, 1.0))"
2846                                                  EOL"#define linear2sRgb(theColor) pow(theColor, 1.0 / vec4(2.2, 2.2, 2.2, 1.0))";
2847       aSrcFrag = aNormalize
2848       + EOL"void main()"
2849         EOL"{"
2850         EOL"  vec4 aColorL = occTexture2D (uLeftSampler,  TexCoord);"
2851         EOL"  vec4 aColorR = occTexture2D (uRightSampler, TexCoord);"
2852         EOL"  aColorL = sRgb2linear (aColorL);"
2853         EOL"  aColorR = sRgb2linear (aColorR);"
2854         EOL"  vec4 aColor = uMultR * aColorR + uMultL * aColorL;"
2855         EOL"  occSetFragColor (linear2sRgb (aColor));"
2856         EOL"}";
2857       break;
2858     }
2859     case Graphic3d_StereoMode_RowInterlaced:
2860     {
2861       aName = "row-interlaced";
2862       aSrcFrag =
2863           EOL"void main()"
2864           EOL"{"
2865           EOL"  vec4 aColorL = occTexture2D (uLeftSampler,  TexCoord);"
2866           EOL"  vec4 aColorR = occTexture2D (uRightSampler, TexCoord);"
2867           EOL"  if (int (mod (gl_FragCoord.y - 1023.5, 2.0)) != 1)"
2868           EOL"  {"
2869           EOL"    occSetFragColor (aColorL);"
2870           EOL"  }"
2871           EOL"  else"
2872           EOL"  {"
2873           EOL"    occSetFragColor (aColorR);"
2874           EOL"  }"
2875           EOL"}";
2876       break;
2877     }
2878     case Graphic3d_StereoMode_ColumnInterlaced:
2879     {
2880       aName = "column-interlaced";
2881       aSrcFrag =
2882           EOL"void main()"
2883           EOL"{"
2884           EOL"  vec4 aColorL = occTexture2D (uLeftSampler,  TexCoord);"
2885           EOL"  vec4 aColorR = occTexture2D (uRightSampler, TexCoord);"
2886           EOL"  if (int (mod (gl_FragCoord.x - 1023.5, 2.0)) == 1)"
2887           EOL"  {"
2888           EOL"    occSetFragColor (aColorL);"
2889           EOL"  }"
2890           EOL"  else"
2891           EOL"  {"
2892           EOL"    occSetFragColor (aColorR);"
2893           EOL"  }"
2894           EOL"}";
2895       break;
2896     }
2897     case Graphic3d_StereoMode_ChessBoard:
2898     {
2899       aName = "chessboard";
2900       aSrcFrag =
2901           EOL"void main()"
2902           EOL"{"
2903           EOL"  vec4 aColorL = occTexture2D (uLeftSampler,  TexCoord);"
2904           EOL"  vec4 aColorR = occTexture2D (uRightSampler, TexCoord);"
2905           EOL"  bool isEvenX = int(mod(floor(gl_FragCoord.x - 1023.5), 2.0)) != 1;"
2906           EOL"  bool isEvenY = int(mod(floor(gl_FragCoord.y - 1023.5), 2.0)) == 1;"
2907           EOL"  if ((isEvenX && isEvenY) || (!isEvenX && !isEvenY))"
2908           EOL"  {"
2909           EOL"    occSetFragColor (aColorL);"
2910           EOL"  }"
2911           EOL"  else"
2912           EOL"  {"
2913           EOL"    occSetFragColor (aColorR);"
2914           EOL"  }"
2915           EOL"}";
2916       break;
2917     }
2918     case Graphic3d_StereoMode_SideBySide:
2919     {
2920       aName = "sidebyside";
2921       aSrcFrag =
2922           EOL"void main()"
2923           EOL"{"
2924           EOL"  vec2 aTexCoord = vec2 (TexCoord.x * 2.0, TexCoord.y);"
2925           EOL"  if (TexCoord.x > 0.5)"
2926           EOL"  {"
2927           EOL"    aTexCoord.x -= 1.0;"
2928           EOL"  }"
2929           EOL"  vec4 aColorL = occTexture2D (uLeftSampler,  aTexCoord);"
2930           EOL"  vec4 aColorR = occTexture2D (uRightSampler, aTexCoord);"
2931           EOL"  if (TexCoord.x <= 0.5)"
2932           EOL"  {"
2933           EOL"    occSetFragColor (aColorL);"
2934           EOL"  }"
2935           EOL"  else"
2936           EOL"  {"
2937           EOL"    occSetFragColor (aColorR);"
2938           EOL"  }"
2939           EOL"}";
2940       break;
2941     }
2942     case Graphic3d_StereoMode_OverUnder:
2943     {
2944       aName = "overunder";
2945       aSrcFrag =
2946           EOL"void main()"
2947           EOL"{"
2948           EOL"  vec2 aTexCoord = vec2 (TexCoord.x, TexCoord.y * 2.0);"
2949           EOL"  if (TexCoord.y > 0.5)"
2950           EOL"  {"
2951           EOL"    aTexCoord.y -= 1.0;"
2952           EOL"  }"
2953           EOL"  vec4 aColorL = occTexture2D (uLeftSampler,  aTexCoord);"
2954           EOL"  vec4 aColorR = occTexture2D (uRightSampler, aTexCoord);"
2955           EOL"  if (TexCoord.y <= 0.5)"
2956           EOL"  {"
2957           EOL"    occSetFragColor (aColorL);"
2958           EOL"  }"
2959           EOL"  else"
2960           EOL"  {"
2961           EOL"    occSetFragColor (aColorR);"
2962           EOL"  }"
2963           EOL"}";
2964       break;
2965     }
2966     case Graphic3d_StereoMode_QuadBuffer:
2967     case Graphic3d_StereoMode_SoftPageFlip:
2968     default:
2969     {
2970       /*const Handle(OpenGl_ShaderProgram)& aProgram = myStereoPrograms[Graphic3d_StereoMode_QuadBuffer];
2971       if (!aProgram.IsNull())
2972       {
2973         return aProgram->IsValid();
2974       }*/
2975       aSrcFrag =
2976           EOL"void main()"
2977           EOL"{"
2978           EOL"  vec4 aColorL = occTexture2D (uLeftSampler,  TexCoord);"
2979           EOL"  vec4 aColorR = occTexture2D (uRightSampler, TexCoord);"
2980           EOL"  aColorL.b = 0.0;"
2981           EOL"  aColorL.g = 0.0;"
2982           EOL"  aColorR.r = 0.0;"
2983           EOL"  occSetFragColor (aColorL + aColorR);"
2984           EOL"}";
2985       break;
2986     }
2987   }
2988
2989   defaultGlslVersion (aProgramSrc, aName, 0);
2990   aProgramSrc->SetDefaultSampler (false);
2991   aProgramSrc->SetNbLightsMax (0);
2992   aProgramSrc->SetNbClipPlanesMax (0);
2993   aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX,   aUniforms, aStageInOuts));
2994   aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts));
2995   TCollection_AsciiString aKey;
2996   if (!Create (aProgramSrc, aKey, theProgram))
2997   {
2998     theProgram = new OpenGl_ShaderProgram(); // just mark as invalid
2999     return Standard_False;
3000   }
3001
3002   myContext->BindProgram (theProgram);
3003   theProgram->SetSampler (myContext, "uLeftSampler",  Graphic3d_TextureUnit_0);
3004   theProgram->SetSampler (myContext, "uRightSampler", Graphic3d_TextureUnit_1);
3005   myContext->BindProgram (NULL);
3006   return Standard_True;
3007 }
3008
3009 // =======================================================================
3010 // function : prepareStdProgramBoundBox
3011 // purpose  :
3012 // =======================================================================
3013 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramBoundBox()
3014 {
3015   Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
3016
3017   OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
3018   aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("vec3 occBBoxCenter", Graphic3d_TOS_VERTEX));
3019   aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("vec3 occBBoxSize",   Graphic3d_TOS_VERTEX));
3020
3021   TCollection_AsciiString aSrcVert =
3022     EOL"void main()"
3023     EOL"{"
3024     EOL"  vec4 aCenter = vec4(occVertex.xyz * occBBoxSize + occBBoxCenter, 1.0);"
3025     EOL"  vec4 aPos    = vec4(occVertex.xyz * occBBoxSize + occBBoxCenter, 1.0);"
3026     EOL"  gl_Position = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix * aPos;"
3027     EOL"}";
3028
3029   TCollection_AsciiString aSrcFrag =
3030     EOL"void main()"
3031     EOL"{"
3032     EOL"  occSetFragColor (occColor);"
3033     EOL"}";
3034
3035   defaultGlslVersion (aProgramSrc, "bndbox", 0);
3036   aProgramSrc->SetDefaultSampler (false);
3037   aProgramSrc->SetNbLightsMax (0);
3038   aProgramSrc->SetNbClipPlanesMax (0);
3039   aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX,   aUniforms, aStageInOuts));
3040   aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts));
3041   TCollection_AsciiString aKey;
3042   if (!Create (aProgramSrc, aKey, myBoundBoxProgram))
3043   {
3044     myBoundBoxProgram = new OpenGl_ShaderProgram(); // just mark as invalid
3045     return Standard_False;
3046   }
3047
3048   const OpenGl_Vec4 aMin (-0.5f, -0.5f, -0.5f, 1.0f);
3049   const OpenGl_Vec4 anAxisShifts[3] =
3050   {
3051     OpenGl_Vec4 (1.0f, 0.0f, 0.0f, 0.0f),
3052     OpenGl_Vec4 (0.0f, 1.0f, 0.0f, 0.0f),
3053     OpenGl_Vec4 (0.0f, 0.0f, 1.0f, 0.0f)
3054   };
3055
3056   const OpenGl_Vec4 aLookup1 (0.0f, 1.0f, 0.0f, 1.0f);
3057   const OpenGl_Vec4 aLookup2 (0.0f, 0.0f, 1.0f, 1.0f);
3058   OpenGl_Vec4 aLinesVertices[24];
3059   for (int anAxis = 0, aVertex = 0; anAxis < 3; ++anAxis)
3060   {
3061     for (int aCompIter = 0; aCompIter < 4; ++aCompIter)
3062     {
3063       aLinesVertices[aVertex++] = aMin
3064         + anAxisShifts[(anAxis + 1) % 3] * aLookup1[aCompIter]
3065         + anAxisShifts[(anAxis + 2) % 3] * aLookup2[aCompIter];
3066
3067       aLinesVertices[aVertex++] = aMin
3068         + anAxisShifts[anAxis]
3069         + anAxisShifts[(anAxis + 1) % 3] * aLookup1[aCompIter]
3070         + anAxisShifts[(anAxis + 2) % 3] * aLookup2[aCompIter];
3071     }
3072   }
3073   if (myContext->ToUseVbo())
3074   {
3075     myBoundBoxVertBuffer = new OpenGl_VertexBuffer();
3076     if (myBoundBoxVertBuffer->Init (myContext, 4, 24, aLinesVertices[0].GetData()))
3077     {
3078       myContext->ShareResource ("OpenGl_ShaderManager_BndBoxVbo", myBoundBoxVertBuffer);
3079       return Standard_True;
3080     }
3081   }
3082   myBoundBoxVertBuffer = new OpenGl_VertexBufferCompat();
3083   myBoundBoxVertBuffer->Init (myContext, 4, 24, aLinesVertices[0].GetData());
3084   myContext->ShareResource ("OpenGl_ShaderManager_BndBoxVbo", myBoundBoxVertBuffer);
3085   return Standard_True;
3086 }
3087
3088 // =======================================================================
3089 // function : preparePBREnvBakingProgram
3090 // purpose  :
3091 // =======================================================================
3092 Standard_Boolean OpenGl_ShaderManager::preparePBREnvBakingProgram()
3093 {
3094   Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
3095   OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
3096
3097   TCollection_AsciiString aSrcVert = TCollection_AsciiString()
3098   + THE_FUNC_cubemap_vector_transform
3099   + Shaders_PBREnvBaking_vs;
3100
3101   TCollection_AsciiString aSrcFrag = TCollection_AsciiString()
3102   + THE_FUNC_cubemap_vector_transform
3103   + Shaders_PBRDistribution_glsl
3104   + Shaders_PBREnvBaking_fs;
3105
3106   // constant array definition requires OpenGL 2.1+ or OpenGL ES 3.0+
3107 #if defined(GL_ES_VERSION_2_0)
3108   aProgramSrc->SetHeader ("#version 300 es");
3109 #else
3110   aProgramSrc->SetHeader ("#version 120");
3111 #endif
3112
3113   defaultGlslVersion (aProgramSrc, "pbr_env_baking", 0);
3114   aProgramSrc->SetDefaultSampler (false);
3115   aProgramSrc->SetNbLightsMax (0);
3116   aProgramSrc->SetNbClipPlanesMax (0);
3117   aProgramSrc->SetPBR (true);
3118   aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX,   aUniforms, aStageInOuts));
3119   aProgramSrc->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts));
3120   TCollection_AsciiString aKey;
3121   if (!Create (aProgramSrc, aKey, myPBREnvBakingProgram))
3122   {
3123     myPBREnvBakingProgram = new OpenGl_ShaderProgram(); // just mark as invalid
3124     return Standard_False;
3125   }
3126
3127   return Standard_True;
3128 }
3129
3130 // =======================================================================
3131 // function : GetBgCubeMapProgram
3132 // purpose  :
3133 // =======================================================================
3134 const Handle(Graphic3d_ShaderProgram)& OpenGl_ShaderManager::GetBgCubeMapProgram ()
3135 {
3136   if (myBgCubeMapProgram.IsNull())
3137   {
3138     myBgCubeMapProgram = new Graphic3d_ShaderProgram();
3139
3140     OpenGl_ShaderObject::ShaderVariableList aUniforms, aStageInOuts;
3141     aStageInOuts.Append (OpenGl_ShaderObject::ShaderVariable("vec3 ViewDirection", Graphic3d_TOS_VERTEX | Graphic3d_TOS_FRAGMENT));
3142     aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("samplerCube occSampler0", Graphic3d_TOS_FRAGMENT));
3143     aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("int uYCoeff", Graphic3d_TOS_VERTEX));
3144     aUniforms.Append (OpenGl_ShaderObject::ShaderVariable ("int uZCoeff", Graphic3d_TOS_VERTEX));
3145
3146     TCollection_AsciiString aSrcVert = TCollection_AsciiString()
3147     + THE_FUNC_cubemap_vector_transform
3148     + EOL"void main()"
3149       EOL"{"
3150       EOL"  vec4 aViewDirection = occProjectionMatrixInverse * vec4(occVertex.xy, 0.0, 1.0);"
3151       EOL"  aViewDirection /= aViewDirection.w;"
3152       EOL"  aViewDirection.w = 0.0;"
3153       EOL"  ViewDirection = normalize((occWorldViewMatrixInverse * aViewDirection).xyz);"
3154       EOL"  ViewDirection = cubemapVectorTransform (ViewDirection, uYCoeff, uZCoeff);"
3155       EOL"  gl_Position = vec4(occVertex.xy, 0.0, 1.0);"
3156       EOL"}";
3157
3158     TCollection_AsciiString aSrcFrag =
3159       EOL"#define occEnvCubemap occSampler0"
3160       EOL"void main()"
3161       EOL"{"
3162       EOL"  occSetFragColor (vec4(occTextureCube (occEnvCubemap, ViewDirection).rgb, 1.0));"
3163       EOL"}";
3164
3165     defaultGlslVersion (myBgCubeMapProgram, "background_cubemap", 0);
3166     myBgCubeMapProgram->SetDefaultSampler (false);
3167     myBgCubeMapProgram->SetNbLightsMax (0);
3168     myBgCubeMapProgram->SetNbClipPlanesMax (0);
3169     myBgCubeMapProgram->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcVert, Graphic3d_TOS_VERTEX, aUniforms, aStageInOuts));
3170     myBgCubeMapProgram->AttachShader (OpenGl_ShaderObject::CreateFromSource (aSrcFrag, Graphic3d_TOS_FRAGMENT, aUniforms, aStageInOuts));
3171   }
3172
3173   return myBgCubeMapProgram;
3174 }
3175
3176 // =======================================================================
3177 // function : bindProgramWithState
3178 // purpose  :
3179 // =======================================================================
3180 Standard_Boolean OpenGl_ShaderManager::bindProgramWithState (const Handle(OpenGl_ShaderProgram)& theProgram)
3181 {
3182   const Standard_Boolean isBound = myContext->BindProgram (theProgram);
3183   if (isBound
3184   && !theProgram.IsNull())
3185   {
3186     theProgram->ApplyVariables (myContext);
3187   }
3188   PushState (theProgram);
3189   return isBound;
3190 }
3191
3192 // =======================================================================
3193 // function : BindMarkerProgram
3194 // purpose  :
3195 // =======================================================================
3196 Standard_Boolean OpenGl_ShaderManager::BindMarkerProgram (const Handle(OpenGl_TextureSet)& theTextures,
3197                                                           Graphic3d_TypeOfShadingModel theShadingModel,
3198                                                           Graphic3d_AlphaMode theAlphaMode,
3199                                                           Standard_Boolean theHasVertColor,
3200                                                           const Handle(OpenGl_ShaderProgram)& theCustomProgram)
3201 {
3202   if (!theCustomProgram.IsNull()
3203     || myContext->caps->ffpEnable)
3204   {
3205     return bindProgramWithState (theCustomProgram);
3206   }
3207
3208   Standard_Integer aBits = getProgramBits (theTextures, theAlphaMode, Aspect_IS_SOLID, theHasVertColor, false, false);
3209   if (!theTextures.IsNull()
3210     && theTextures->HasPointSprite())
3211   {
3212     aBits |= theTextures->Last()->IsAlpha() ? OpenGl_PO_PointSpriteA : OpenGl_PO_PointSprite;
3213   }
3214   else
3215   {
3216     aBits |= OpenGl_PO_PointSimple;
3217   }
3218   Handle(OpenGl_ShaderProgram)& aProgram = getStdProgram (theShadingModel, aBits);
3219   return bindProgramWithState (aProgram);
3220 }