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