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_AspectFace.hxx>
  20 #include <OpenGl_AspectLine.hxx>
  21 #include <OpenGl_AspectMarker.hxx>
  22 #include <OpenGl_AspectText.hxx>
  23 #include <OpenGl_ClippingIterator.hxx>
  24 #include <OpenGl_Context.hxx>
  25 #include <OpenGl_ShaderManager.hxx>
  26 #include <OpenGl_ShaderProgram.hxx>
  27 #include <OpenGl_VertexBufferCompat.hxx>
  28 #include <OpenGl_Workspace.hxx>
  29
  30 #include <TCollection_ExtendedString.hxx>
  31
  32 IMPLEMENT_STANDARD_RTTIEXT(OpenGl_ShaderManager,Standard_Transient)
  33
  34 namespace
  35 {
  36   //! Number specifying maximum number of light sources to prepare a GLSL program with unrolled loop.
  37   const Standard_Integer THE_NB_UNROLLED_LIGHTS_MAX = 32;
  38
  39   //! Compute the size of array storing holding light sources definition.
  40   static Standard_Integer roundUpMaxLightSources (Standard_Integer theNbLights)
  41   {
  42     Standard_Integer aMaxLimit = THE_NB_UNROLLED_LIGHTS_MAX;
  43     for (; aMaxLimit < theNbLights; aMaxLimit *= 2) {}
  44     return aMaxLimit;
  45   }
  46
  47 #define EOL "\n"
  48
  49 //! Definition of TexCoord varying.
  50 const char THE_VARY_TexCoord_OUT[] =
  51   EOL"THE_SHADER_OUT vec4 TexCoord;";
  52 const char THE_VARY_TexCoord_IN[] =
  53   EOL"THE_SHADER_IN  vec4 TexCoord;";
  54 //! Compute TexCoord value in Vertex Shader
  55 const char THE_VARY_TexCoord_Trsf[] =
  56   EOL"  float aRotSin = occTextureTrsf_RotationSin();"
  57   EOL"  float aRotCos = occTextureTrsf_RotationCos();"
  58   EOL"  vec2  aTex2   = (occTexCoord.xy + occTextureTrsf_Translation()) * occTextureTrsf_Scale();"
  59   EOL"  vec2  aCopy   = aTex2;"
  60   EOL"  aTex2.x = aCopy.x * aRotCos - aCopy.y * aRotSin;"
  61   EOL"  aTex2.y = aCopy.x * aRotSin + aCopy.y * aRotCos;"
  62   EOL"  TexCoord = vec4(aTex2, occTexCoord.zw);";
  63
  64 //! Auxiliary function to flip gl_PointCoord vertically
  65 #define THE_VEC2_glPointCoord "vec2 (gl_PointCoord.x, 1.0 - gl_PointCoord.y)"
  66
  67 //! Auxiliary function to transform normal
  68 const char THE_FUNC_transformNormal[] =
  69   EOL"vec3 transformNormal (in vec3 theNormal)"
  70   EOL"{"
  71   EOL"  vec4 aResult = occWorldViewMatrixInverseTranspose"
  72   EOL"               * occModelWorldMatrixInverseTranspose"
  73   EOL"               * vec4 (theNormal, 0.0);"
  74   EOL"  return normalize (aResult.xyz);"
  75   EOL"}";
  76
  77 //! Global shader variable for color definition with lighting enabled.
  78 const char THE_FUNC_lightDef[] =
  79   EOL"vec3 Ambient;"   //!< Ambient  contribution of light sources
  80   EOL"vec3 Diffuse;"   //!< Diffuse  contribution of light sources
  81   EOL"vec3 Specular;"; //!< Specular contribution of light sources
  82
  83 //! Function computes contribution of isotropic point light source
  84 const char THE_FUNC_pointLight[] =
  85   EOL"void pointLight (in int  theId,"
  86   EOL"                 in vec3 theNormal,"
  87   EOL"                 in vec3 theView,"
  88   EOL"                 in vec3 thePoint,"
  89   EOL"                 in bool theIsFront)"
  90   EOL"{"
  91   EOL"  vec3 aLight = occLight_Position (theId).xyz;"
  92   EOL"  if (occLight_IsHeadlight (theId) == 0)"
  93   EOL"  {"
  94   EOL"    aLight = vec3 (occWorldViewMatrix * vec4 (aLight, 1.0));"
  95   EOL"  }"
  96   EOL"  aLight -= thePoint;"
  97   EOL
  98   EOL"  float aDist = length (aLight);"
  99   EOL"  aLight = aLight * (1.0 / aDist);"
 100   EOL
 101   EOL"  float anAtten = 1.0 / (occLight_ConstAttenuation  (theId)"
 102   EOL"                       + occLight_LinearAttenuation (theId) * aDist);"
 103   EOL
 104   EOL"  vec3 aHalf = normalize (aLight + theView);"
 105   EOL
 106   EOL"  vec3  aFaceSideNormal = theIsFront ? theNormal : -theNormal;"
 107   EOL"  float aNdotL = max (0.0, dot (aFaceSideNormal, aLight));"
 108   EOL"  float aNdotH = max (0.0, dot (aFaceSideNormal, aHalf ));"
 109   EOL
 110   EOL"  float aSpecl = 0.0;"
 111   EOL"  if (aNdotL > 0.0)"
 112   EOL"  {"
 113   EOL"    aSpecl = pow (aNdotH, theIsFront ? occFrontMaterial_Shininess() : occBackMaterial_Shininess());"
 114   EOL"  }"
 115   EOL
 116   EOL"Diffuse  += occLight_Diffuse  (theId).rgb * aNdotL * anAtten;"
 117   EOL"Specular += occLight_Specular (theId).rgb * aSpecl * anAtten;"
 118   EOL"}";
 119
 120 //! Function computes contribution of spotlight source
 121 const char THE_FUNC_spotLight[] =
 122   EOL"void spotLight (in int  theId,"
 123   EOL"                in vec3 theNormal,"
 124   EOL"                in vec3 theView,"
 125   EOL"                in vec3 thePoint,"
 126   EOL"                in bool theIsFront)"
 127   EOL"{"
 128   EOL"  vec3 aLight   = occLight_Position      (theId).xyz;"
 129   EOL"  vec3 aSpotDir = occLight_SpotDirection (theId).xyz;"
 130   EOL"  if (occLight_IsHeadlight (theId) == 0)"
 131   EOL"  {"
 132   EOL"    aLight   = vec3 (occWorldViewMatrix * vec4 (aLight,   1.0));"
 133   EOL"    aSpotDir = vec3 (occWorldViewMatrix * vec4 (aSpotDir, 0.0));"
 134   EOL"  }"
 135   EOL"  aLight -= thePoint;"
 136   EOL
 137   EOL"  float aDist = length (aLight);"
 138   EOL"  aLight = aLight * (1.0 / aDist);"
 139   EOL
 140   EOL"  aSpotDir = normalize (aSpotDir);"
 141   // light cone
 142   EOL"  float aCosA = dot (aSpotDir, -aLight);"
 143   EOL"  if (aCosA >= 1.0 || aCosA < cos (occLight_SpotCutOff (theId)))"
 144   EOL"  {"
 145   EOL"    return;"
 146   EOL"  }"
 147   EOL
 148   EOL"  float anExponent = occLight_SpotExponent (theId);"
 149   EOL"  float anAtten    = 1.0 / (occLight_ConstAttenuation  (theId)"
 150   EOL"                          + occLight_LinearAttenuation (theId) * aDist);"
 151   EOL"  if (anExponent > 0.0)"
 152   EOL"  {"
 153   EOL"    anAtten *= pow (aCosA, anExponent * 128.0);"
 154   EOL"  }"
 155   EOL
 156   EOL"  vec3 aHalf = normalize (aLight + theView);"
 157   EOL
 158   EOL"  vec3  aFaceSideNormal = theIsFront ? theNormal : -theNormal;"
 159   EOL"  float aNdotL = max (0.0, dot (aFaceSideNormal, aLight));"
 160   EOL"  float aNdotH = max (0.0, dot (aFaceSideNormal, aHalf ));"
 161   EOL
 162   EOL"  float aSpecl = 0.0;"
 163   EOL"  if (aNdotL > 0.0)"
 164   EOL"  {"
 165   EOL"    aSpecl = pow (aNdotH, theIsFront ? occFrontMaterial_Shininess() : occBackMaterial_Shininess());"
 166   EOL"  }"
 167   EOL
 168   EOL"  Diffuse  += occLight_Diffuse  (theId).rgb * aNdotL * anAtten;"
 169   EOL"  Specular += occLight_Specular (theId).rgb * aSpecl * anAtten;"
 170   EOL"}";
 171
 172 //! Function computes contribution of directional light source
 173 const char THE_FUNC_directionalLight[] =
 174   EOL"void directionalLight (in int  theId,"
 175   EOL"                       in vec3 theNormal,"
 176   EOL"                       in vec3 theView,"
 177   EOL"                       in bool theIsFront)"
 178   EOL"{"
 179   EOL"  vec3 aLight = normalize (occLight_Position (theId).xyz);"
 180   EOL"  if (occLight_IsHeadlight (theId) == 0)"
 181   EOL"  {"
 182   EOL"    aLight = vec3 (occWorldViewMatrix * vec4 (aLight, 0.0));"
 183   EOL"  }"
 184   EOL
 185   EOL"  vec3 aHalf = normalize (aLight + theView);"
 186   EOL
 187   EOL"  vec3  aFaceSideNormal = theIsFront ? theNormal : -theNormal;"
 188   EOL"  float aNdotL = max (0.0, dot (aFaceSideNormal, aLight));"
 189   EOL"  float aNdotH = max (0.0, dot (aFaceSideNormal, aHalf ));"
 190   EOL
 191   EOL"  float aSpecl = 0.0;"
 192   EOL"  if (aNdotL > 0.0)"
 193   EOL"  {"
 194   EOL"    aSpecl = pow (aNdotH, theIsFront ? occFrontMaterial_Shininess() : occBackMaterial_Shininess());"
 195   EOL"  }"
 196   EOL
 197   EOL"  Diffuse  += occLight_Diffuse  (theId).rgb * aNdotL;"
 198   EOL"  Specular += occLight_Specular (theId).rgb * aSpecl;"
 199   EOL"}";
 200
 201 //! The same as THE_FUNC_directionalLight but for the light with zero index
 202 //! (avoids limitations on some mobile devices).
 203 const char THE_FUNC_directionalLightFirst[] =
 204   EOL"void directionalLightFirst (in vec3 theNormal,"
 205   EOL"                            in vec3 theView,"
 206   EOL"                            in bool theIsFront)"
 207   EOL"{"
 208   EOL"  vec3 aLight = normalize (occLightSources[1].xyz);"
 209   EOL"  if (occLight_IsHeadlight (0) == 0)"
 210   EOL"  {"
 211   EOL"    aLight = vec3 (occWorldViewMatrix * vec4 (aLight, 0.0));"
 212   EOL"  }"
 213   EOL
 214   EOL"  vec3 aHalf = normalize (aLight + theView);"
 215   EOL
 216   EOL"  vec3  aFaceSideNormal = theIsFront ? theNormal : -theNormal;"
 217   EOL"  float aNdotL = max (0.0, dot (aFaceSideNormal, aLight));"
 218   EOL"  float aNdotH = max (0.0, dot (aFaceSideNormal, aHalf ));"
 219   EOL
 220   EOL"  float aSpecl = 0.0;"
 221   EOL"  if (aNdotL > 0.0)"
 222   EOL"  {"
 223   EOL"    aSpecl = pow (aNdotH, theIsFront ? occFrontMaterial_Shininess() : occBackMaterial_Shininess());"
 224   EOL"  }"
 225   EOL
 226   EOL"  Diffuse  += occLightSources[0].rgb * aNdotL;"
 227   EOL"  Specular += occLightSources[0].rgb * aSpecl;"
 228   EOL"}";
 229
 230 //! Process clipping planes in Fragment Shader.
 231 //! Should be added at the beginning of the main() function.
 232 const char THE_FRAG_CLIP_PLANES_N[] =
 233   EOL"  for (int aPlaneIter = 0; aPlaneIter < occClipPlaneCount; ++aPlaneIter)"
 234   EOL"  {"
 235   EOL"    vec4 aClipEquation = occClipPlaneEquations[aPlaneIter];"
 236   EOL"    if (dot (aClipEquation.xyz, PositionWorld.xyz / PositionWorld.w) + aClipEquation.w < 0.0)"
 237   EOL"    {"
 238   EOL"      discard;"
 239   EOL"    }"
 240   EOL"  }";
 241
 242 //! Process chains of clipping planes in Fragment Shader.
 243 const char THE_FRAG_CLIP_CHAINS_N[] =
 244 EOL"  for (int aPlaneIter = 0; aPlaneIter < occClipPlaneCount;)"
 245 EOL"  {"
 246 EOL"    vec4 aClipEquation = occClipPlaneEquations[aPlaneIter];"
 247 EOL"    if (dot (aClipEquation.xyz, PositionWorld.xyz / PositionWorld.w) + aClipEquation.w < 0.0)"
 248 EOL"    {"
 249 EOL"      if (occClipPlaneChains[aPlaneIter] == 1)"
 250 EOL"      {"
 251 EOL"        discard;"
 252 EOL"      }"
 253 EOL"      aPlaneIter += 1;"
 254 EOL"    }"
 255 EOL"    else"
 256 EOL"    {"
 257 EOL"      aPlaneIter += occClipPlaneChains[aPlaneIter];"
 258 EOL"    }"
 259 EOL"  }";
 260
 261 //! Process 1 clipping plane in Fragment Shader.
 262 const char THE_FRAG_CLIP_PLANES_1[] =
 263   EOL"  vec4 aClipEquation0 = occClipPlaneEquations[0];"
 264   EOL"  if (dot (aClipEquation0.xyz, PositionWorld.xyz / PositionWorld.w) + aClipEquation0.w < 0.0)"
 265   EOL"  {"
 266   EOL"    discard;"
 267   EOL"  }";
 268
 269 //! Process 2 clipping planes in Fragment Shader.
 270 const char THE_FRAG_CLIP_PLANES_2[] =
 271   EOL"  vec4 aClipEquation0 = occClipPlaneEquations[0];"
 272   EOL"  vec4 aClipEquation1 = occClipPlaneEquations[1];"
 273   EOL"  if (dot (aClipEquation0.xyz, PositionWorld.xyz / PositionWorld.w) + aClipEquation0.w < 0.0"
 274   EOL"   || dot (aClipEquation1.xyz, PositionWorld.xyz / PositionWorld.w) + aClipEquation1.w < 0.0)"
 275   EOL"  {"
 276   EOL"    discard;"
 277   EOL"  }";
 278
 279 //! Process a chain of 2 clipping planes in Fragment Shader (3/4 section).
 280 const char THE_FRAG_CLIP_CHAINS_2[] =
 281 EOL"  vec4 aClipEquation0 = occClipPlaneEquations[0];"
 282 EOL"  vec4 aClipEquation1 = occClipPlaneEquations[1];"
 283 EOL"  if (dot (aClipEquation0.xyz, PositionWorld.xyz / PositionWorld.w) + aClipEquation0.w < 0.0"
 284 EOL"   && dot (aClipEquation1.xyz, PositionWorld.xyz / PositionWorld.w) + aClipEquation1.w < 0.0)"
 285 EOL"  {"
 286 EOL"    discard;"
 287 EOL"  }";
 288
 289 #if !defined(GL_ES_VERSION_2_0)
 290
 291   static const GLfloat THE_DEFAULT_AMBIENT[4]    = { 0.0f, 0.0f, 0.0f, 1.0f };
 292   static const GLfloat THE_DEFAULT_SPOT_DIR[3]   = { 0.0f, 0.0f, -1.0f };
 293   static const GLfloat THE_DEFAULT_SPOT_EXPONENT = 0.0f;
 294   static const GLfloat THE_DEFAULT_SPOT_CUTOFF   = 180.0f;
 295
 296   //! Bind FFP light source.
 297   static void bindLight (const Graphic3d_CLight& theLight,
 298                          const GLenum        theLightGlId,
 299                          const OpenGl_Mat4&  theModelView,
 300                          OpenGl_Context*     theCtx)
 301   {
 302     // the light is a headlight?
 303     if (theLight.IsHeadlight())
 304     {
 305       theCtx->core11->glMatrixMode (GL_MODELVIEW);
 306       theCtx->core11->glLoadIdentity();
 307     }
 308
 309     // setup light type
 310     const Graphic3d_Vec4& aLightColor = theLight.PackedColor();
 311     switch (theLight.Type())
 312     {
 313       case Graphic3d_TOLS_AMBIENT    : break; // handled by separate if-clause at beginning of method
 314       case Graphic3d_TOLS_DIRECTIONAL:
 315       {
 316         // if the last parameter of GL_POSITION, is zero, the corresponding light source is a Directional one
 317         const OpenGl_Vec4 anInfDir = -theLight.PackedDirection();
 318
 319         // to create a realistic effect,  set the GL_SPECULAR parameter to the same value as the GL_DIFFUSE.
 320         theCtx->core11->glLightfv (theLightGlId, GL_AMBIENT,               THE_DEFAULT_AMBIENT);
 321         theCtx->core11->glLightfv (theLightGlId, GL_DIFFUSE,               aLightColor.GetData());
 322         theCtx->core11->glLightfv (theLightGlId, GL_SPECULAR,              aLightColor.GetData());
 323         theCtx->core11->glLightfv (theLightGlId, GL_POSITION,              anInfDir.GetData());
 324         theCtx->core11->glLightfv (theLightGlId, GL_SPOT_DIRECTION,        THE_DEFAULT_SPOT_DIR);
 325         theCtx->core11->glLightf  (theLightGlId, GL_SPOT_EXPONENT,         THE_DEFAULT_SPOT_EXPONENT);
 326         theCtx->core11->glLightf  (theLightGlId, GL_SPOT_CUTOFF,           THE_DEFAULT_SPOT_CUTOFF);
 327         break;
 328       }
 329       case Graphic3d_TOLS_POSITIONAL:
 330       {
 331         // to create a realistic effect, set the GL_SPECULAR parameter to the same value as the GL_DIFFUSE
 332         const OpenGl_Vec4 aPosition (static_cast<float>(theLight.Position().X()), static_cast<float>(theLight.Position().Y()), static_cast<float>(theLight.Position().Z()), 1.0f);
 333         theCtx->core11->glLightfv (theLightGlId, GL_AMBIENT,               THE_DEFAULT_AMBIENT);
 334         theCtx->core11->glLightfv (theLightGlId, GL_DIFFUSE,               aLightColor.GetData());
 335         theCtx->core11->glLightfv (theLightGlId, GL_SPECULAR,              aLightColor.GetData());
 336         theCtx->core11->glLightfv (theLightGlId, GL_POSITION,              aPosition.GetData());
 337         theCtx->core11->glLightfv (theLightGlId, GL_SPOT_DIRECTION,        THE_DEFAULT_SPOT_DIR);
 338         theCtx->core11->glLightf  (theLightGlId, GL_SPOT_EXPONENT,         THE_DEFAULT_SPOT_EXPONENT);
 339         theCtx->core11->glLightf  (theLightGlId, GL_SPOT_CUTOFF,           THE_DEFAULT_SPOT_CUTOFF);
 340         theCtx->core11->glLightf  (theLightGlId, GL_CONSTANT_ATTENUATION,  theLight.ConstAttenuation());
 341         theCtx->core11->glLightf  (theLightGlId, GL_LINEAR_ATTENUATION,    theLight.LinearAttenuation());
 342         theCtx->core11->glLightf  (theLightGlId, GL_QUADRATIC_ATTENUATION, 0.0);
 343         break;
 344       }
 345       case Graphic3d_TOLS_SPOT:
 346       {
 347         const OpenGl_Vec4 aPosition (static_cast<float>(theLight.Position().X()), static_cast<float>(theLight.Position().Y()), static_cast<float>(theLight.Position().Z()), 1.0f);
 348         theCtx->core11->glLightfv (theLightGlId, GL_AMBIENT,               THE_DEFAULT_AMBIENT);
 349         theCtx->core11->glLightfv (theLightGlId, GL_DIFFUSE,               aLightColor.GetData());
 350         theCtx->core11->glLightfv (theLightGlId, GL_SPECULAR,              aLightColor.GetData());
 351         theCtx->core11->glLightfv (theLightGlId, GL_POSITION,              aPosition.GetData());
 352         theCtx->core11->glLightfv (theLightGlId, GL_SPOT_DIRECTION,        theLight.PackedDirection().GetData());
 353         theCtx->core11->glLightf  (theLightGlId, GL_SPOT_EXPONENT,         theLight.Concentration() * 128.0f);
 354         theCtx->core11->glLightf  (theLightGlId, GL_SPOT_CUTOFF,          (theLight.Angle() * 180.0f) / GLfloat(M_PI));
 355         theCtx->core11->glLightf  (theLightGlId, GL_CONSTANT_ATTENUATION,  theLight.ConstAttenuation());
 356         theCtx->core11->glLightf  (theLightGlId, GL_LINEAR_ATTENUATION,    theLight.LinearAttenuation());
 357         theCtx->core11->glLightf  (theLightGlId, GL_QUADRATIC_ATTENUATION, 0.0f);
 358         break;
 359       }
 360     }
 361
 362     // restore matrix in case of headlight
 363     if (theLight.IsHeadlight())
 364     {
 365       theCtx->core11->glLoadMatrixf (theModelView.GetData());
 366     }
 367
 368     glEnable (theLightGlId);
 369   }
 370 #endif
 371
 372 }
 373
 374 // =======================================================================
 375 // function : OpenGl_ShaderManager
 376 // purpose  : Creates new empty shader manager
 377 // =======================================================================
 378 OpenGl_ShaderManager::OpenGl_ShaderManager (OpenGl_Context* theContext)
 379 : myFfpProgram (new OpenGl_ShaderProgramFFP()),
 380   myShadingModel (Graphic3d_TOSM_VERTEX),
 381   myUnlitPrograms (new OpenGl_SetOfShaderPrograms()),
 382   myContext  (theContext),
 383   myHasLocalOrigin (Standard_False),
 384   myLastView (NULL)
 385 {
 386   //
 387 }
 388
 389 // =======================================================================
 390 // function : ~OpenGl_ShaderManager
 391 // purpose  : Releases resources of shader manager
 392 // =======================================================================
 393 OpenGl_ShaderManager::~OpenGl_ShaderManager()
 394 {
 395   myProgramList.Clear();
 396 }
 397
 398 // =======================================================================
 399 // function : clear
 400 // purpose  :
 401 // =======================================================================
 402 void OpenGl_ShaderManager::clear()
 403 {
 404   myProgramList.Clear();
 405   myLightPrograms.Nullify();
 406   myUnlitPrograms = new OpenGl_SetOfShaderPrograms();
 407   myMapOfLightPrograms.Clear();
 408   myFontProgram.Nullify();
 409   myBlitProgram.Nullify();
 410   myBoundBoxProgram.Nullify();
 411   myBoundBoxVertBuffer.Nullify();
 412   for (Standard_Integer aModeIter = 0; aModeIter < Graphic3d_StereoMode_NB; ++aModeIter)
 413   {
 414     myStereoPrograms[aModeIter].Nullify();
 415   }
 416   switchLightPrograms();
 417 }
 418
 419 // =======================================================================
 420 // function : Create
 421 // purpose  : Creates new shader program
 422 // =======================================================================
 423 Standard_Boolean OpenGl_ShaderManager::Create (const Handle(Graphic3d_ShaderProgram)& theProxy,
 424                                                TCollection_AsciiString&               theShareKey,
 425                                                Handle(OpenGl_ShaderProgram)&          theProgram)
 426 {
 427   theProgram.Nullify();
 428   if (theProxy.IsNull())
 429   {
 430     return Standard_False;
 431   }
 432
 433   theShareKey = theProxy->GetId();
 434   if (myContext->GetResource<Handle(OpenGl_ShaderProgram)> (theShareKey, theProgram))
 435   {
 436     if (theProgram->Share())
 437     {
 438       myProgramList.Append (theProgram);
 439     }
 440     return Standard_True;
 441   }
 442
 443   theProgram = new OpenGl_ShaderProgram (theProxy);
 444   if (!theProgram->Initialize (myContext, theProxy->ShaderObjects()))
 445   {
 446     theProgram->Release (myContext);
 447     theShareKey.Clear();
 448     theProgram.Nullify();
 449     return Standard_False;
 450   }
 451
 452   myProgramList.Append (theProgram);
 453   myContext->ShareResource (theShareKey, theProgram);
 454   return Standard_True;
 455 }
 456
 457 // =======================================================================
 458 // function : Unregister
 459 // purpose  : Removes specified shader program from the manager
 460 // =======================================================================
 461 void OpenGl_ShaderManager::Unregister (TCollection_AsciiString&      theShareKey,
 462                                        Handle(OpenGl_ShaderProgram)& theProgram)
 463 {
 464   for (OpenGl_ShaderProgramList::Iterator anIt (myProgramList); anIt.More(); anIt.Next())
 465   {
 466     if (anIt.Value() == theProgram)
 467     {
 468       if (!theProgram->UnShare())
 469       {
 470         theShareKey.Clear();
 471         theProgram.Nullify();
 472         return;
 473       }
 474
 475       myProgramList.Remove (anIt);
 476       break;
 477     }
 478   }
 479
 480   const TCollection_AsciiString anID = theProgram->myProxy->GetId();
 481   if (anID.IsEmpty())
 482   {
 483     myContext->DelayedRelease (theProgram);
 484     theProgram.Nullify();
 485   }
 486   else
 487   {
 488     theProgram.Nullify();
 489     myContext->ReleaseResource (anID, Standard_True);
 490   }
 491 }
 492
 493 // =======================================================================
 494 // function : ShaderPrograms
 495 // purpose  : Returns list of registered shader programs
 496 // =======================================================================
 497 const OpenGl_ShaderProgramList& OpenGl_ShaderManager::ShaderPrograms() const
 498 {
 499   return myProgramList;
 500 }
 501
 502 // =======================================================================
 503 // function : Empty
 504 // purpose  : Returns true if no program objects are attached
 505 // =======================================================================
 506 Standard_Boolean OpenGl_ShaderManager::IsEmpty() const
 507 {
 508   return myProgramList.IsEmpty();
 509 }
 510
 511 // =======================================================================
 512 // function : switchLightPrograms
 513 // purpose  :
 514 // =======================================================================
 515 void OpenGl_ShaderManager::switchLightPrograms()
 516 {
 517   const Handle(Graphic3d_LightSet)& aLights = myLightSourceState.LightSources();
 518   if (aLights.IsNull())
 519   {
 520     myLightPrograms = myUnlitPrograms;
 521     return;
 522   }
 523
 524   TCollection_AsciiString aKey ("l_");
 525   if (aLights->NbEnabled() <= THE_NB_UNROLLED_LIGHTS_MAX)
 526   {
 527     aKey += aLights->KeyEnabledLong();
 528   }
 529   else
 530   {
 531     const Standard_Integer aMaxLimit = roundUpMaxLightSources (aLights->NbEnabled());
 532     aKey += aLights->KeyEnabledShort();
 533     aKey += aMaxLimit;
 534   }
 535
 536   if (!myMapOfLightPrograms.Find (aKey, myLightPrograms))
 537   {
 538     myLightPrograms = new OpenGl_SetOfShaderPrograms();
 539     myMapOfLightPrograms.Bind (aKey, myLightPrograms);
 540   }
 541 }
 542
 543 // =======================================================================
 544 // function : UpdateLightSourceStateTo
 545 // purpose  : Updates state of OCCT light sources
 546 // =======================================================================
 547 void OpenGl_ShaderManager::UpdateLightSourceStateTo (const Handle(Graphic3d_LightSet)& theLights)
 548 {
 549   myLightSourceState.Set (theLights);
 550   myLightSourceState.Update();
 551   switchLightPrograms();
 552 }
 553
 554 // =======================================================================
 555 // function : UpdateLightSourceState
 556 // purpose  :
 557 // =======================================================================
 558 void OpenGl_ShaderManager::UpdateLightSourceState()
 559 {
 560   myLightSourceState.Update();
 561 }
 562
 563 // =======================================================================
 564 // function : SetShadingModel
 565 // purpose  :
 566 // =======================================================================
 567 void OpenGl_ShaderManager::SetShadingModel (const Graphic3d_TypeOfShadingModel theModel)
 568 {
 569   if (theModel == Graphic3d_TOSM_DEFAULT)
 570   {
 571     throw Standard_ProgramError ("OpenGl_ShaderManager::SetShadingModel() - attempt to set invalid Shading Model!");
 572   }
 573
 574   myShadingModel = theModel;
 575   switchLightPrograms();
 576 }
 577
 578 // =======================================================================
 579 // function : SetProjectionState
 580 // purpose  : Sets new state of OCCT projection transform
 581 // =======================================================================
 582 void OpenGl_ShaderManager::UpdateProjectionStateTo (const OpenGl_Mat4& theProjectionMatrix)
 583 {
 584   myProjectionState.Set (theProjectionMatrix);
 585   myProjectionState.Update();
 586 }
 587
 588 // =======================================================================
 589 // function : SetModelWorldState
 590 // purpose  : Sets new state of OCCT model-world transform
 591 // =======================================================================
 592 void OpenGl_ShaderManager::UpdateModelWorldStateTo (const OpenGl_Mat4& theModelWorldMatrix)
 593 {
 594   myModelWorldState.Set (theModelWorldMatrix);
 595   myModelWorldState.Update();
 596 }
 597
 598 // =======================================================================
 599 // function : SetWorldViewState
 600 // purpose  : Sets new state of OCCT world-view transform
 601 // =======================================================================
 602 void OpenGl_ShaderManager::UpdateWorldViewStateTo (const OpenGl_Mat4& theWorldViewMatrix)
 603 {
 604   myWorldViewState.Set (theWorldViewMatrix);
 605   myWorldViewState.Update();
 606 }
 607
 608 // =======================================================================
 609 // function : PushLightSourceState
 610 // purpose  : Pushes state of OCCT light sources to the program
 611 // =======================================================================
 612 void OpenGl_ShaderManager::PushLightSourceState (const Handle(OpenGl_ShaderProgram)& theProgram) const
 613 {
 614   if (myLightSourceState.Index() == theProgram->ActiveState (OpenGl_LIGHT_SOURCES_STATE))
 615   {
 616     return;
 617   }
 618
 619   theProgram->UpdateState (OpenGl_LIGHT_SOURCES_STATE, myLightSourceState.Index());
 620   if (theProgram == myFfpProgram)
 621   {
 622   #if !defined(GL_ES_VERSION_2_0)
 623     if (myContext->core11 == NULL)
 624     {
 625       return;
 626     }
 627
 628     GLenum aLightGlId = GL_LIGHT0;
 629     const OpenGl_Mat4 aModelView = myWorldViewState.WorldViewMatrix() * myModelWorldState.ModelWorldMatrix();
 630     for (Graphic3d_LightSet::Iterator aLightIt (myLightSourceState.LightSources(), Graphic3d_LightSet::IterationFilter_ExcludeDisabledAndAmbient);
 631          aLightIt.More(); aLightIt.Next())
 632     {
 633       if (aLightGlId > GL_LIGHT7) // only 8 lights in FFP...
 634       {
 635         myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_MEDIUM,
 636                                 "Warning: light sources limit (8) has been exceeded within Fixed-function pipeline.");
 637         continue;
 638       }
 639
 640       bindLight (*aLightIt.Value(), aLightGlId, aModelView, myContext);
 641       ++aLightGlId;
 642     }
 643
 644     // apply accumulated ambient color
 645     const Graphic3d_Vec4 anAmbient = !myLightSourceState.LightSources().IsNull()
 646                                     ? myLightSourceState.LightSources()->AmbientColor()
 647                                     : Graphic3d_Vec4 (0.0f, 0.0f, 0.0f, 1.0f);
 648     myContext->core11->glLightModelfv (GL_LIGHT_MODEL_AMBIENT, anAmbient.GetData());
 649
 650     // GL_LIGHTING is managed by drawers to switch between shaded / no lighting output,
 651     // therefore managing the state here does not have any effect - do it just for consistency.
 652     if (aLightGlId != GL_LIGHT0)
 653     {
 654       ::glEnable (GL_LIGHTING);
 655     }
 656     else
 657     {
 658       ::glDisable (GL_LIGHTING);
 659     }
 660     // switch off unused lights
 661     for (; aLightGlId <= GL_LIGHT7; ++aLightGlId)
 662     {
 663       ::glDisable (aLightGlId);
 664     }
 665   #endif
 666     return;
 667   }
 668
 669   const Standard_Integer aNbLightsMax = theProgram->NbLightsMax();
 670   const GLint anAmbientLoc = theProgram->GetStateLocation (OpenGl_OCC_LIGHT_AMBIENT);
 671   if (aNbLightsMax == 0
 672    && anAmbientLoc == OpenGl_ShaderProgram::INVALID_LOCATION)
 673   {
 674     return;
 675   }
 676
 677   if (myLightTypeArray.Size() < aNbLightsMax)
 678   {
 679     myLightTypeArray  .Resize (0, aNbLightsMax - 1, false);
 680     myLightParamsArray.Resize (0, aNbLightsMax - 1, false);
 681   }
 682   for (Standard_Integer aLightIt = 0; aLightIt < aNbLightsMax; ++aLightIt)
 683   {
 684     myLightTypeArray.ChangeValue (aLightIt).Type = -1;
 685   }
 686
 687   if (myLightSourceState.LightSources().IsNull()
 688    || myLightSourceState.LightSources()->IsEmpty())
 689   {
 690     theProgram->SetUniform (myContext,
 691                             theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_COUNT),
 692                             0);
 693     theProgram->SetUniform (myContext,
 694                             anAmbientLoc,
 695                             OpenGl_Vec4 (0.0f, 0.0f, 0.0f, 0.0f));
 696     theProgram->SetUniform (myContext,
 697                             theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_TYPES),
 698                             aNbLightsMax * OpenGl_ShaderLightType::NbOfVec2i(),
 699                             myLightTypeArray.First().Packed());
 700     return;
 701   }
 702
 703   Standard_Integer aLightsNb = 0;
 704   for (Graphic3d_LightSet::Iterator anIter (myLightSourceState.LightSources(), Graphic3d_LightSet::IterationFilter_ExcludeDisabledAndAmbient);
 705        anIter.More(); anIter.Next())
 706   {
 707     const Graphic3d_CLight& aLight = *anIter.Value();
 708     if (aLightsNb >= aNbLightsMax)
 709     {
 710       if (aNbLightsMax != 0)
 711       {
 712         myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_MEDIUM,
 713                                 TCollection_AsciiString("Warning: light sources limit (") + aNbLightsMax + ") has been exceeded.");
 714       }
 715       continue;
 716     }
 717
 718     OpenGl_ShaderLightType&       aLightType   = myLightTypeArray.ChangeValue (aLightsNb);
 719     OpenGl_ShaderLightParameters& aLightParams = myLightParamsArray.ChangeValue (aLightsNb);
 720     if (!aLight.IsEnabled()) // has no affect with Graphic3d_LightSet::IterationFilter_ExcludeDisabled - here just for consistency
 721     {
 722       // 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
 723       aLightType.Type        = -1; // Graphic3d_TOLS_AMBIENT can be used instead
 724       aLightType.IsHeadlight = false;
 725       aLightParams.Color     = OpenGl_Vec4 (0.0f, 0.0f, 0.0f, 0.0f);
 726       ++aLightsNb;
 727       continue;
 728     }
 729
 730     aLightType.Type        = aLight.Type();
 731     aLightType.IsHeadlight = aLight.IsHeadlight();
 732     aLightParams.Color     = aLight.PackedColor();
 733     if (aLight.Type() == Graphic3d_TOLS_DIRECTIONAL)
 734     {
 735       aLightParams.Position = -aLight.PackedDirection();
 736     }
 737     else if (!aLight.IsHeadlight())
 738     {
 739       aLightParams.Position.x() = static_cast<float>(aLight.Position().X() - myLocalOrigin.X());
 740       aLightParams.Position.y() = static_cast<float>(aLight.Position().Y() - myLocalOrigin.Y());
 741       aLightParams.Position.z() = static_cast<float>(aLight.Position().Z() - myLocalOrigin.Z());
 742       aLightParams.Position.w() = 1.0f;
 743     }
 744     else
 745     {
 746       aLightParams.Position.x() = static_cast<float>(aLight.Position().X());
 747       aLightParams.Position.y() = static_cast<float>(aLight.Position().Y());
 748       aLightParams.Position.z() = static_cast<float>(aLight.Position().Z());
 749       aLightParams.Position.w() = 1.0f;
 750     }
 751
 752     if (aLight.Type() == Graphic3d_TOLS_SPOT)
 753     {
 754       aLightParams.Direction = aLight.PackedDirection();
 755     }
 756     aLightParams.Parameters = aLight.PackedParams();
 757     ++aLightsNb;
 758   }
 759
 760   const Graphic3d_Vec4& anAmbient = myLightSourceState.LightSources()->AmbientColor();
 761   theProgram->SetUniform (myContext,
 762                           theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_COUNT),
 763                           aLightsNb);
 764   theProgram->SetUniform (myContext,
 765                           anAmbientLoc,
 766                           anAmbient);
 767   theProgram->SetUniform (myContext,
 768                           theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_TYPES),
 769                           aNbLightsMax * OpenGl_ShaderLightType::NbOfVec2i(),
 770                           myLightTypeArray.First().Packed());
 771   if (aLightsNb > 0)
 772   {
 773     theProgram->SetUniform (myContext,
 774                             theProgram->GetStateLocation (OpenGl_OCC_LIGHT_SOURCE_PARAMS),
 775                             aLightsNb * OpenGl_ShaderLightParameters::NbOfVec4(),
 776                             myLightParamsArray.First().Packed());
 777   }
 778 }
 779
 780 // =======================================================================
 781 // function : PushProjectionState
 782 // purpose  : Pushes state of OCCT projection transform to the program
 783 // =======================================================================
 784 void OpenGl_ShaderManager::PushProjectionState (const Handle(OpenGl_ShaderProgram)& theProgram) const
 785 {
 786   if (myProjectionState.Index() == theProgram->ActiveState (OpenGl_PROJECTION_STATE))
 787   {
 788     return;
 789   }
 790
 791   theProgram->UpdateState (OpenGl_PROJECTION_STATE, myProjectionState.Index());
 792   if (theProgram == myFfpProgram)
 793   {
 794   #if !defined(GL_ES_VERSION_2_0)
 795     if (myContext->core11 != NULL)
 796     {
 797       myContext->core11->glMatrixMode (GL_PROJECTION);
 798       myContext->core11->glLoadMatrixf (myProjectionState.ProjectionMatrix());
 799     }
 800   #endif
 801     return;
 802   }
 803
 804   theProgram->SetUniform (myContext,
 805                           theProgram->GetStateLocation (OpenGl_OCC_PROJECTION_MATRIX),
 806                           myProjectionState.ProjectionMatrix());
 807
 808   GLint aLocation = theProgram->GetStateLocation (OpenGl_OCC_PROJECTION_MATRIX_INVERSE);
 809   if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
 810   {
 811     theProgram->SetUniform (myContext, aLocation, myProjectionState.ProjectionMatrixInverse());
 812   }
 813
 814   theProgram->SetUniform (myContext,
 815                           theProgram->GetStateLocation (OpenGl_OCC_PROJECTION_MATRIX_TRANSPOSE),
 816                           myProjectionState.ProjectionMatrix(), true);
 817
 818   aLocation = theProgram->GetStateLocation (OpenGl_OCC_PROJECTION_MATRIX_INVERSE_TRANSPOSE);
 819   if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
 820   {
 821     theProgram->SetUniform (myContext, aLocation, myProjectionState.ProjectionMatrixInverse(), true);
 822   }
 823 }
 824
 825 // =======================================================================
 826 // function : PushModelWorldState
 827 // purpose  : Pushes state of OCCT model-world transform to the program
 828 // =======================================================================
 829 void OpenGl_ShaderManager::PushModelWorldState (const Handle(OpenGl_ShaderProgram)& theProgram) const
 830 {
 831   if (myModelWorldState.Index() == theProgram->ActiveState (OpenGl_MODEL_WORLD_STATE))
 832   {
 833     return;
 834   }
 835
 836   theProgram->UpdateState (OpenGl_MODEL_WORLD_STATE, myModelWorldState.Index());
 837   if (theProgram == myFfpProgram)
 838   {
 839   #if !defined(GL_ES_VERSION_2_0)
 840     if (myContext->core11 != NULL)
 841     {
 842       const OpenGl_Mat4 aModelView = myWorldViewState.WorldViewMatrix() * myModelWorldState.ModelWorldMatrix();
 843       myContext->core11->glMatrixMode (GL_MODELVIEW);
 844       myContext->core11->glLoadMatrixf (aModelView.GetData());
 845       theProgram->UpdateState (OpenGl_WORLD_VIEW_STATE, myWorldViewState.Index());
 846     }
 847   #endif
 848     return;
 849   }
 850
 851   theProgram->SetUniform (myContext,
 852                           theProgram->GetStateLocation (OpenGl_OCC_MODEL_WORLD_MATRIX),
 853                           myModelWorldState.ModelWorldMatrix());
 854
 855   GLint aLocation = theProgram->GetStateLocation (OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE);
 856   if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
 857   {
 858     theProgram->SetUniform (myContext, aLocation, myModelWorldState.ModelWorldMatrixInverse());
 859   }
 860
 861   theProgram->SetUniform (myContext,
 862                           theProgram->GetStateLocation (OpenGl_OCC_MODEL_WORLD_MATRIX_TRANSPOSE),
 863                           myModelWorldState.ModelWorldMatrix(), true);
 864
 865   aLocation = theProgram->GetStateLocation (OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE_TRANSPOSE);
 866   if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
 867   {
 868     theProgram->SetUniform (myContext, aLocation, myModelWorldState.ModelWorldMatrixInverse(), true);
 869   }
 870 }
 871
 872 // =======================================================================
 873 // function : PushWorldViewState
 874 // purpose  : Pushes state of OCCT world-view transform to the program
 875 // =======================================================================
 876 void OpenGl_ShaderManager::PushWorldViewState (const Handle(OpenGl_ShaderProgram)& theProgram) const
 877 {
 878   if (myWorldViewState.Index() == theProgram->ActiveState (OpenGl_WORLD_VIEW_STATE))
 879   {
 880     return;
 881   }
 882
 883   theProgram->UpdateState (OpenGl_WORLD_VIEW_STATE, myWorldViewState.Index());
 884   if (theProgram == myFfpProgram)
 885   {
 886   #if !defined(GL_ES_VERSION_2_0)
 887     if (myContext->core11 != NULL)
 888     {
 889       const OpenGl_Mat4 aModelView = myWorldViewState.WorldViewMatrix() * myModelWorldState.ModelWorldMatrix();
 890       myContext->core11->glMatrixMode (GL_MODELVIEW);
 891       myContext->core11->glLoadMatrixf (aModelView.GetData());
 892       theProgram->UpdateState (OpenGl_MODEL_WORLD_STATE, myModelWorldState.Index());
 893     }
 894   #endif
 895     return;
 896   }
 897
 898   theProgram->SetUniform (myContext,
 899                           theProgram->GetStateLocation (OpenGl_OCC_WORLD_VIEW_MATRIX),
 900                           myWorldViewState.WorldViewMatrix());
 901
 902   GLint aLocation = theProgram->GetStateLocation (OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE);
 903   if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
 904   {
 905     theProgram->SetUniform (myContext, aLocation, myWorldViewState.WorldViewMatrixInverse());
 906   }
 907
 908   theProgram->SetUniform (myContext,
 909                           theProgram->GetStateLocation (OpenGl_OCC_WORLD_VIEW_MATRIX_TRANSPOSE),
 910                           myWorldViewState.WorldViewMatrix(), true);
 911
 912   aLocation = theProgram->GetStateLocation (OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE_TRANSPOSE);
 913   if (aLocation != OpenGl_ShaderProgram::INVALID_LOCATION)
 914   {
 915     theProgram->SetUniform (myContext, aLocation, myWorldViewState.WorldViewMatrixInverse(), true);
 916   }
 917 }
 918
 919 // =======================================================================
 920 // function : UpdateClippingState
 921 // purpose  : Updates state of OCCT clipping planes
 922 // =======================================================================
 923 void OpenGl_ShaderManager::UpdateClippingState()
 924 {
 925   myClippingState.Update();
 926 }
 927
 928 // =======================================================================
 929 // function : RevertClippingState
 930 // purpose  : Reverts state of OCCT clipping planes
 931 // =======================================================================
 932 void OpenGl_ShaderManager::RevertClippingState()
 933 {
 934   myClippingState.Revert();
 935 }
 936
 937 // =======================================================================
 938 // function : PushClippingState
 939 // purpose  : Pushes state of OCCT clipping planes to the program
 940 // =======================================================================
 941 void OpenGl_ShaderManager::PushClippingState (const Handle(OpenGl_ShaderProgram)& theProgram) const
 942 {
 943   if (myClippingState.Index() == theProgram->ActiveState (OpenGl_CLIP_PLANES_STATE))
 944   {
 945     return;
 946   }
 947
 948   theProgram->UpdateState (OpenGl_CLIP_PLANES_STATE, myClippingState.Index());
 949   if (theProgram == myFfpProgram)
 950   {
 951   #if !defined(GL_ES_VERSION_2_0)
 952     if (myContext->core11 == NULL)
 953     {
 954       return;
 955     }
 956
 957     const Standard_Integer aNbMaxPlanes = myContext->MaxClipPlanes();
 958     if (myClipPlaneArrayFfp.Size() < aNbMaxPlanes)
 959     {
 960       myClipPlaneArrayFfp.Resize (0, aNbMaxPlanes - 1, false);
 961     }
 962
 963     Standard_Integer aPlaneId = 0;
 964     Standard_Boolean toRestoreModelView = Standard_False;
 965     const Handle(Graphic3d_ClipPlane)& aCappedChain = myContext->Clipping().CappedChain();
 966     for (OpenGl_ClippingIterator aPlaneIter (myContext->Clipping()); aPlaneIter.More(); aPlaneIter.Next())
 967     {
 968       const Handle(Graphic3d_ClipPlane)& aPlane = aPlaneIter.Value();
 969       if (aPlaneIter.IsDisabled()
 970        || aPlane->IsChain()
 971        || (aPlane == aCappedChain
 972         && myContext->Clipping().IsCappingEnableAllExcept()))
 973       {
 974         continue;
 975       }
 976       else if (aPlaneId >= aNbMaxPlanes)
 977       {
 978         myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_MEDIUM,
 979                                 TCollection_ExtendedString("Warning: clipping planes limit (") + aNbMaxPlanes + ") has been exceeded.");
 980         break;
 981       }
 982
 983       const Graphic3d_ClipPlane::Equation& anEquation = aPlane->GetEquation();
 984       OpenGl_Vec4d& aPlaneEq = myClipPlaneArrayFfp.ChangeValue (aPlaneId);
 985       aPlaneEq.x() = anEquation.x();
 986       aPlaneEq.y() = anEquation.y();
 987       aPlaneEq.z() = anEquation.z();
 988       aPlaneEq.w() = anEquation.w();
 989       if (myHasLocalOrigin)
 990       {
 991         const gp_XYZ        aPos = aPlane->ToPlane().Position().Location().XYZ() - myLocalOrigin;
 992         const Standard_Real aD   = -(anEquation.x() * aPos.X() + anEquation.y() * aPos.Y() + anEquation.z() * aPos.Z());
 993         aPlaneEq.w() = aD;
 994       }
 995
 996       const GLenum anFfpPlaneID = GL_CLIP_PLANE0 + aPlaneId;
 997       if (anFfpPlaneID == GL_CLIP_PLANE0)
 998       {
 999         // set either identity or pure view matrix
1000         toRestoreModelView = Standard_True;
1001         myContext->core11->glMatrixMode (GL_MODELVIEW);
1002         myContext->core11->glLoadMatrixf (myWorldViewState.WorldViewMatrix().GetData());
1003       }
1004
1005       ::glEnable (anFfpPlaneID);
1006       myContext->core11->glClipPlane (anFfpPlaneID, aPlaneEq);
1007
1008       ++aPlaneId;
1009     }
1010
1011     // switch off unused lights
1012     for (; aPlaneId < aNbMaxPlanes; ++aPlaneId)
1013     {
1014       ::glDisable (GL_CLIP_PLANE0 + aPlaneId);
1015     }
1016
1017     // restore combined model-view matrix
1018     if (toRestoreModelView)
1019     {
1020       const OpenGl_Mat4 aModelView = myWorldViewState.WorldViewMatrix() * myModelWorldState.ModelWorldMatrix();
1021       myContext->core11->glLoadMatrixf (aModelView.GetData());
1022     }
1023   #endif
1024     return;
1025   }
1026
1027   const GLint aLocEquations = theProgram->GetStateLocation (OpenGl_OCC_CLIP_PLANE_EQUATIONS);
1028   if (aLocEquations == OpenGl_ShaderProgram::INVALID_LOCATION)
1029   {
1030     return;
1031   }
1032
1033   const Standard_Integer aNbClipPlanesMax = theProgram->NbClipPlanesMax();
1034   const Standard_Integer aNbPlanes = Min (myContext->Clipping().NbClippingOrCappingOn(), aNbClipPlanesMax);
1035   if (aNbPlanes < 1)
1036   {
1037     theProgram->SetUniform (myContext, theProgram->GetStateLocation (OpenGl_OCC_CLIP_PLANE_COUNT), 0);
1038     return;
1039   }
1040
1041   if (myClipPlaneArray.Size() < aNbClipPlanesMax)
1042   {
1043     myClipPlaneArray.Resize (0, aNbClipPlanesMax - 1, false);
1044     myClipChainArray.Resize (0, aNbClipPlanesMax - 1, false);
1045   }
1046
1047   Standard_Integer aPlaneId = 0;
1048   const Handle(Graphic3d_ClipPlane)& aCappedChain = myContext->Clipping().CappedChain();
1049   for (OpenGl_ClippingIterator aPlaneIter (myContext->Clipping()); aPlaneIter.More(); aPlaneIter.Next())
1050   {
1051     const Handle(Graphic3d_ClipPlane)& aPlane = aPlaneIter.Value();
1052     if (aPlaneIter.IsDisabled())
1053     {
1054       continue;
1055     }
1056
1057     if (myContext->Clipping().IsCappingDisableAllExcept())
1058     {
1059       // enable only specific (sub) plane
1060       if (aPlane != aCappedChain)
1061       {
1062         continue;
1063       }
1064
1065       Standard_Integer aSubPlaneIndex = 1;
1066       for (const Graphic3d_ClipPlane* aSubPlaneIter = aCappedChain.get(); aSubPlaneIter != NULL; aSubPlaneIter = aSubPlaneIter->ChainNextPlane().get(), ++aSubPlaneIndex)
1067       {
1068         if (aSubPlaneIndex == myContext->Clipping().CappedSubPlane())
1069         {
1070           addClippingPlane (aPlaneId, *aSubPlaneIter, aSubPlaneIter->GetEquation(), 1);
1071           break;
1072         }
1073       }
1074       break;
1075     }
1076     else if (aPlane == aCappedChain) // && myContext->Clipping().IsCappingEnableAllExcept()
1077     {
1078       // enable sub-planes within processed Chain as reversed and ORed, excluding filtered plane
1079       if (aPlaneId + aPlane->NbChainNextPlanes() - 1 > aNbClipPlanesMax)
1080       {
1081         myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_HIGH,
1082                                 TCollection_AsciiString("Error: clipping planes limit (") + aNbClipPlanesMax + ") has been exceeded.");
1083         break;
1084       }
1085
1086       Standard_Integer aSubPlaneIndex = 1;
1087       for (const Graphic3d_ClipPlane* aSubPlaneIter = aPlane.get(); aSubPlaneIter != NULL; aSubPlaneIter = aSubPlaneIter->ChainNextPlane().get(), ++aSubPlaneIndex)
1088       {
1089         if (aSubPlaneIndex != -myContext->Clipping().CappedSubPlane())
1090         {
1091           addClippingPlane (aPlaneId, *aSubPlaneIter, aSubPlaneIter->ReversedEquation(), 1);
1092         }
1093       }
1094     }
1095     else
1096     {
1097       // normal case
1098       if (aPlaneId + aPlane->NbChainNextPlanes() > aNbClipPlanesMax)
1099       {
1100         myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_HIGH,
1101                                 TCollection_AsciiString("Error: clipping planes limit (") + aNbClipPlanesMax + ") has been exceeded.");
1102         break;
1103       }
1104       for (const Graphic3d_ClipPlane* aSubPlaneIter = aPlane.get(); aSubPlaneIter != NULL; aSubPlaneIter = aSubPlaneIter->ChainNextPlane().get())
1105       {
1106         addClippingPlane (aPlaneId, *aSubPlaneIter, aSubPlaneIter->GetEquation(), aSubPlaneIter->NbChainNextPlanes());
1107       }
1108     }
1109   }
1110
1111   theProgram->SetUniform (myContext, theProgram->GetStateLocation (OpenGl_OCC_CLIP_PLANE_COUNT), aPlaneId);
1112   theProgram->SetUniform (myContext, aLocEquations, aNbClipPlanesMax, &myClipPlaneArray.First());
1113   theProgram->SetUniform (myContext, theProgram->GetStateLocation (OpenGl_OCC_CLIP_PLANE_CHAINS), aNbClipPlanesMax, &myClipChainArray.First());
1114 }
1115
1116 // =======================================================================
1117 // function : PushMaterialState
1118 // purpose  :
1119 // =======================================================================
1120 void OpenGl_ShaderManager::PushMaterialState (const Handle(OpenGl_ShaderProgram)& theProgram) const
1121 {
1122   if (myMaterialState.Index() == theProgram->ActiveState (OpenGl_MATERIAL_STATE))
1123   {
1124     return;
1125   }
1126
1127   const OpenGl_Material& aFrontMat = myMaterialState.FrontMaterial();
1128   const OpenGl_Material& aBackMat  = myMaterialState.BackMaterial();
1129   theProgram->UpdateState (OpenGl_MATERIAL_STATE, myMaterialState.Index());
1130   if (theProgram == myFfpProgram)
1131   {
1132   #if !defined(GL_ES_VERSION_2_0)
1133     if (myContext->core11 == NULL)
1134     {
1135       return;
1136     }
1137
1138     if (myMaterialState.AlphaCutoff() < ShortRealLast())
1139     {
1140       glAlphaFunc (GL_GEQUAL, myMaterialState.AlphaCutoff());
1141       glEnable (GL_ALPHA_TEST);
1142     }
1143     else
1144     {
1145       glDisable (GL_ALPHA_TEST);
1146     }
1147
1148     const GLenum aFrontFace = myMaterialState.ToDistinguish() ? GL_FRONT : GL_FRONT_AND_BACK;
1149     myContext->core11->glMaterialfv(aFrontFace, GL_AMBIENT,   aFrontMat.Ambient.GetData());
1150     myContext->core11->glMaterialfv(aFrontFace, GL_DIFFUSE,   aFrontMat.Diffuse.GetData());
1151     myContext->core11->glMaterialfv(aFrontFace, GL_SPECULAR,  aFrontMat.Specular.GetData());
1152     myContext->core11->glMaterialfv(aFrontFace, GL_EMISSION,  aFrontMat.Emission.GetData());
1153     myContext->core11->glMaterialf (aFrontFace, GL_SHININESS, aFrontMat.Shine());
1154     if (myMaterialState.ToDistinguish())
1155     {
1156       myContext->core11->glMaterialfv(GL_BACK, GL_AMBIENT,   aBackMat.Ambient.GetData());
1157       myContext->core11->glMaterialfv(GL_BACK, GL_DIFFUSE,   aBackMat.Diffuse.GetData());
1158       myContext->core11->glMaterialfv(GL_BACK, GL_SPECULAR,  aBackMat.Specular.GetData());
1159       myContext->core11->glMaterialfv(GL_BACK, GL_EMISSION,  aBackMat.Emission.GetData());
1160       myContext->core11->glMaterialf (GL_BACK, GL_SHININESS, aBackMat.Shine());
1161     }
1162   #endif
1163     return;
1164   }
1165
1166   theProgram->SetUniform (myContext,
1167                           theProgram->GetStateLocation (OpenGl_OCCT_ALPHA_CUTOFF),
1168                           myMaterialState.AlphaCutoff());
1169   theProgram->SetUniform (myContext,
1170                           theProgram->GetStateLocation (OpenGl_OCCT_TEXTURE_ENABLE),
1171                           myMaterialState.ToMapTexture()  ? 1 : 0);
1172   theProgram->SetUniform (myContext,
1173                           theProgram->GetStateLocation (OpenGl_OCCT_DISTINGUISH_MODE),
1174                           myMaterialState.ToDistinguish() ? 1 : 0);
1175
1176   const GLint aLocFront = theProgram->GetStateLocation (OpenGl_OCCT_FRONT_MATERIAL);
1177   if (aLocFront != OpenGl_ShaderProgram::INVALID_LOCATION)
1178   {
1179     theProgram->SetUniform (myContext, aLocFront, OpenGl_Material::NbOfVec4(),
1180                             aFrontMat.Packed());
1181   }
1182
1183   const GLint aLocBack = theProgram->GetStateLocation (OpenGl_OCCT_BACK_MATERIAL);
1184   if (aLocBack != OpenGl_ShaderProgram::INVALID_LOCATION)
1185   {
1186     theProgram->SetUniform (myContext, aLocBack,  OpenGl_Material::NbOfVec4(),
1187                             aBackMat.Packed());
1188   }
1189 }
1190
1191 // =======================================================================
1192 // function : PushOitState
1193 // purpose  : Pushes state of OIT uniforms to the specified program
1194 // =======================================================================
1195 void OpenGl_ShaderManager::PushOitState (const Handle(OpenGl_ShaderProgram)& theProgram) const
1196 {
1197   if (!theProgram->IsValid())
1198   {
1199     return;
1200   }
1201
1202   if (myOitState.Index() == theProgram->ActiveState (OpenGL_OIT_STATE))
1203   {
1204     return;
1205   }
1206
1207   const GLint aLocOutput = theProgram->GetStateLocation (OpenGl_OCCT_OIT_OUTPUT);
1208   if (aLocOutput != OpenGl_ShaderProgram::INVALID_LOCATION)
1209   {
1210     theProgram->SetUniform (myContext, aLocOutput, myOitState.ToEnableWrite());
1211   }
1212
1213   const GLint aLocDepthFactor = theProgram->GetStateLocation (OpenGl_OCCT_OIT_DEPTH_FACTOR);
1214   if (aLocDepthFactor != OpenGl_ShaderProgram::INVALID_LOCATION)
1215   {
1216     theProgram->SetUniform (myContext, aLocDepthFactor, myOitState.DepthFactor());
1217   }
1218 }
1219
1220 // =======================================================================
1221 // function : PushState
1222 // purpose  : Pushes state of OCCT graphics parameters to the program
1223 // =======================================================================
1224 void OpenGl_ShaderManager::PushState (const Handle(OpenGl_ShaderProgram)& theProgram) const
1225 {
1226   const Handle(OpenGl_ShaderProgram)& aProgram = !theProgram.IsNull() ? theProgram : myFfpProgram;
1227   PushClippingState    (aProgram);
1228   PushWorldViewState   (aProgram);
1229   PushModelWorldState  (aProgram);
1230   PushProjectionState  (aProgram);
1231   PushLightSourceState (aProgram);
1232   PushMaterialState    (aProgram);
1233   PushOitState         (aProgram);
1234 }
1235
1236 // =======================================================================
1237 // function : prepareStdProgramFont
1238 // purpose  :
1239 // =======================================================================
1240 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramFont()
1241 {
1242   Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
1243   TCollection_AsciiString aSrcVert = TCollection_AsciiString()
1244      + EOL"THE_SHADER_OUT vec2 TexCoord;"
1245        EOL"void main()"
1246        EOL"{"
1247        EOL"  TexCoord = occTexCoord.st;"
1248        EOL"  gl_Position = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix * occVertex;"
1249        EOL"}";
1250
1251   TCollection_AsciiString
1252     aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occSamplerBaseColor, TexCoord.st).a; }";
1253 #if !defined(GL_ES_VERSION_2_0)
1254   if (myContext->core11 == NULL)
1255   {
1256     aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occSamplerBaseColor, TexCoord.st).r; }";
1257   }
1258 #endif
1259
1260   TCollection_AsciiString aSrcFrag = TCollection_AsciiString() +
1261      + EOL"THE_SHADER_IN vec2 TexCoord;"
1262      + aSrcGetAlpha
1263      + EOL"void main()"
1264        EOL"{"
1265        EOL"  vec4 aColor = occColor;"
1266        EOL"  aColor.a *= getAlpha();"
1267        EOL"  if (aColor.a <= 0.285) discard;"
1268        EOL"  occSetFragColor (aColor);"
1269        EOL"}";
1270
1271 #if !defined(GL_ES_VERSION_2_0)
1272   if (myContext->core32 != NULL)
1273   {
1274     aProgramSrc->SetHeader ("#version 150");
1275   }
1276 #else
1277   if (myContext->IsGlGreaterEqual (3, 1))
1278   {
1279     // prefer "100 es" on OpenGL ES 3.0 devices
1280     // and    "300 es" on newer devices (3.1+)
1281     aProgramSrc->SetHeader ("#version 300 es");
1282   }
1283 #endif
1284   aProgramSrc->SetNbLightsMax (0);
1285   aProgramSrc->SetNbClipPlanesMax (0);
1286   aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_VERTEX,   aSrcVert));
1287   aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_FRAGMENT, aSrcFrag));
1288   TCollection_AsciiString aKey;
1289   if (!Create (aProgramSrc, aKey, myFontProgram))
1290   {
1291     myFontProgram = new OpenGl_ShaderProgram(); // just mark as invalid
1292     return Standard_False;
1293   }
1294   return Standard_True;
1295 }
1296
1297 // =======================================================================
1298 // function : prepareStdProgramFboBlit
1299 // purpose  :
1300 // =======================================================================
1301 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramFboBlit()
1302 {
1303   Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
1304   TCollection_AsciiString aSrcVert =
1305       EOL"THE_SHADER_OUT vec2 TexCoord;"
1306       EOL"void main()"
1307       EOL"{"
1308       EOL"  TexCoord    = occVertex.zw;"
1309       EOL"  gl_Position = vec4(occVertex.x, occVertex.y, 0.0, 1.0);"
1310       EOL"}";
1311
1312   TCollection_AsciiString aSrcFrag =
1313       EOL"uniform sampler2D uColorSampler;"
1314       EOL"uniform sampler2D uDepthSampler;"
1315       EOL
1316       EOL"THE_SHADER_IN vec2 TexCoord;"
1317       EOL
1318       EOL"void main()"
1319       EOL"{"
1320       EOL"  gl_FragDepth = occTexture2D (uDepthSampler, TexCoord).r;"
1321       EOL"  occSetFragColor (occTexture2D (uColorSampler, TexCoord));"
1322       EOL"}";
1323
1324 #if defined(GL_ES_VERSION_2_0)
1325   if (myContext->IsGlGreaterEqual (3, 0))
1326   {
1327     aProgramSrc->SetHeader ("#version 300 es");
1328   }
1329   else if (myContext->extFragDepth)
1330   {
1331     aProgramSrc->SetHeader ("#extension GL_EXT_frag_depth : enable"
1332                          EOL"#define gl_FragDepth gl_FragDepthEXT");
1333   }
1334   else
1335   {
1336     // there is no way to draw into depth buffer
1337     aSrcFrag =
1338       EOL"uniform sampler2D uColorSampler;"
1339       EOL
1340       EOL"THE_SHADER_IN vec2 TexCoord;"
1341       EOL
1342       EOL"void main()"
1343       EOL"{"
1344       EOL"  occSetFragColor (occTexture2D (uColorSampler, TexCoord));"
1345       EOL"}";
1346   }
1347 #else
1348   if (myContext->core32 != NULL)
1349   {
1350     aProgramSrc->SetHeader ("#version 150");
1351   }
1352 #endif
1353   aProgramSrc->SetNbLightsMax (0);
1354   aProgramSrc->SetNbClipPlanesMax (0);
1355   aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_VERTEX,   aSrcVert));
1356   aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_FRAGMENT, aSrcFrag));
1357   TCollection_AsciiString aKey;
1358   if (!Create (aProgramSrc, aKey, myBlitProgram))
1359   {
1360     myBlitProgram = new OpenGl_ShaderProgram(); // just mark as invalid
1361     return Standard_False;
1362   }
1363
1364   myContext->BindProgram (myBlitProgram);
1365   myBlitProgram->SetSampler (myContext, "uColorSampler", Graphic3d_TextureUnit_0);
1366   myBlitProgram->SetSampler (myContext, "uDepthSampler", Graphic3d_TextureUnit_1);
1367   myContext->BindProgram (NULL);
1368   return Standard_True;
1369 }
1370
1371 // =======================================================================
1372 // function : prepareStdProgramOitCompositing
1373 // purpose  :
1374 // =======================================================================
1375 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramOitCompositing (const Standard_Boolean theMsaa)
1376 {
1377   Handle(OpenGl_ShaderProgram)& aProgram = myOitCompositingProgram[theMsaa ? 1 : 0];
1378   Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
1379   TCollection_AsciiString aSrcVert, aSrcFrag;
1380
1381   aSrcVert =
1382     EOL"THE_SHADER_OUT vec2 TexCoord;"
1383     EOL"void main()"
1384     EOL"{"
1385     EOL"  TexCoord    = occVertex.zw;"
1386     EOL"  gl_Position = vec4 (occVertex.x, occVertex.y, 0.0, 1.0);"
1387     EOL"}";
1388
1389   if (!theMsaa)
1390   {
1391     aSrcFrag =
1392       EOL"uniform sampler2D uAccumTexture;"
1393       EOL"uniform sampler2D uWeightTexture;"
1394       EOL
1395       EOL"THE_SHADER_IN vec2 TexCoord;"
1396       EOL
1397       EOL"void main()"
1398       EOL"{"
1399       EOL"  vec4 aAccum   = occTexture2D (uAccumTexture,  TexCoord);"
1400       EOL"  float aWeight = occTexture2D (uWeightTexture, TexCoord).r;"
1401       EOL"  occSetFragColor (vec4 (aAccum.rgb / max (aWeight, 0.00001), aAccum.a));"
1402       EOL"}";
1403   #if !defined(GL_ES_VERSION_2_0)
1404     if (myContext->IsGlGreaterEqual (3, 2))
1405     {
1406       aProgramSrc->SetHeader ("#version 150");
1407     }
1408   #else
1409     if (myContext->IsGlGreaterEqual (3, 0))
1410     {
1411       aProgramSrc->SetHeader ("#version 300 es");
1412     }
1413   #endif
1414   }
1415   else
1416   {
1417     aSrcFrag =
1418       EOL"uniform sampler2DMS uAccumTexture;"
1419       EOL"uniform sampler2DMS uWeightTexture;"
1420       EOL
1421       EOL"THE_SHADER_IN vec2 TexCoord;"
1422       EOL
1423       EOL"void main()"
1424       EOL"{"
1425       EOL"  ivec2 aTexel  = ivec2 (vec2 (textureSize (uAccumTexture)) * TexCoord);"
1426       EOL"  vec4 aAccum   = texelFetch (uAccumTexture,  aTexel, gl_SampleID);"
1427       EOL"  float aWeight = texelFetch (uWeightTexture, aTexel, gl_SampleID).r;"
1428       EOL"  occSetFragColor (vec4 (aAccum.rgb / max (aWeight, 0.00001), aAccum.a));"
1429       EOL"}";
1430   #if !defined(GL_ES_VERSION_2_0)
1431     if (myContext->IsGlGreaterEqual (4, 0))
1432     {
1433       aProgramSrc->SetHeader ("#version 400");
1434     }
1435   #else
1436     if (myContext->IsGlGreaterEqual (3, 2))
1437     {
1438       aProgramSrc->SetHeader ("#version 320 es");
1439     }
1440     else if (myContext->IsGlGreaterEqual (3, 0))
1441     {
1442       aProgramSrc->SetHeader ("#version 300 es"); // with GL_OES_sample_variables extension
1443     }
1444   #endif
1445   }
1446
1447   aProgramSrc->SetNbLightsMax (0);
1448   aProgramSrc->SetNbClipPlanesMax (0);
1449   aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_VERTEX,   aSrcVert));
1450   aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_FRAGMENT, aSrcFrag));
1451   TCollection_AsciiString aKey;
1452   if (!Create (aProgramSrc, aKey, aProgram))
1453   {
1454     aProgram = new OpenGl_ShaderProgram(); // just mark as invalid
1455     return Standard_False;
1456   }
1457
1458   myContext->BindProgram (aProgram);
1459   aProgram->SetSampler (myContext, "uAccumTexture",  Graphic3d_TextureUnit_0);
1460   aProgram->SetSampler (myContext, "uWeightTexture", Graphic3d_TextureUnit_1);
1461   myContext->BindProgram (Handle(OpenGl_ShaderProgram)());
1462   return Standard_True;
1463 }
1464
1465 // =======================================================================
1466 // function : pointSpriteAlphaSrc
1467 // purpose  :
1468 // =======================================================================
1469 TCollection_AsciiString OpenGl_ShaderManager::pointSpriteAlphaSrc (const Standard_Integer theBits)
1470 {
1471   TCollection_AsciiString aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occSamplerBaseColor, " THE_VEC2_glPointCoord ").a; }";
1472 #if !defined(GL_ES_VERSION_2_0)
1473   if (myContext->core11 == NULL
1474    && (theBits & OpenGl_PO_TextureA) != 0)
1475   {
1476     aSrcGetAlpha = EOL"float getAlpha(void) { return occTexture2D(occSamplerBaseColor, " THE_VEC2_glPointCoord ").r; }";
1477   }
1478 #else
1479   (void )theBits;
1480 #endif
1481   return aSrcGetAlpha;
1482 }
1483
1484 namespace
1485 {
1486
1487   // =======================================================================
1488   // function : textureUsed
1489   // purpose  :
1490   // =======================================================================
1491   static bool textureUsed (const Standard_Integer theBits)
1492   {
1493     return (theBits & OpenGl_PO_TextureA) != 0 || (theBits & OpenGl_PO_TextureRGB) != 0;
1494   }
1495
1496 }
1497
1498 // =======================================================================
1499 // function : prepareStdProgramUnlit
1500 // purpose  :
1501 // =======================================================================
1502 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramUnlit (Handle(OpenGl_ShaderProgram)& theProgram,
1503                                                                const Standard_Integer        theBits)
1504 {
1505   Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
1506   TCollection_AsciiString aSrcVert, aSrcVertExtraOut, aSrcVertExtraMain, aSrcVertExtraFunc, aSrcGetAlpha;
1507   TCollection_AsciiString aSrcFrag, aSrcFragExtraOut, aSrcFragExtraMain, aSrcFragWriteOit;
1508   TCollection_AsciiString aSrcFragGetColor     = EOL"vec4 getColor(void) { return occColor; }";
1509   TCollection_AsciiString aSrcFragMainGetColor = EOL"  occSetFragColor (getColor());";
1510   if ((theBits & OpenGl_PO_Point) != 0)
1511   {
1512   #if defined(GL_ES_VERSION_2_0)
1513     aSrcVertExtraMain += EOL"  gl_PointSize = occPointSize;";
1514   #endif
1515
1516     if ((theBits & OpenGl_PO_TextureRGB) != 0)
1517     {
1518       aSrcFragGetColor =
1519         EOL"vec4 getColor(void) { return occTexture2D(occSamplerBaseColor, " THE_VEC2_glPointCoord "); }";
1520     }
1521
1522     if (textureUsed (theBits))
1523     {
1524       aSrcGetAlpha = pointSpriteAlphaSrc (theBits);
1525
1526     #if !defined(GL_ES_VERSION_2_0)
1527       if (myContext->core11 != NULL
1528         && myContext->IsGlGreaterEqual (2, 1))
1529       {
1530         aProgramSrc->SetHeader ("#version 120"); // gl_PointCoord has been added since GLSL 1.2
1531       }
1532     #endif
1533
1534       aSrcFragMainGetColor =
1535         EOL"  vec4 aColor = getColor();"
1536         EOL"  aColor.a = getAlpha();"
1537         EOL"  if (aColor.a <= 0.1) discard;"
1538         EOL"  occSetFragColor (aColor);";
1539     }
1540     else
1541     {
1542       aSrcFragMainGetColor =
1543         EOL"  vec4 aColor = getColor();"
1544         EOL"  if (aColor.a <= 0.1) discard;"
1545         EOL"  occSetFragColor (aColor);";
1546     }
1547   }
1548   else
1549   {
1550     if ((theBits & OpenGl_PO_TextureRGB) != 0)
1551     {
1552       aSrcVertExtraOut  += THE_VARY_TexCoord_OUT;
1553       aSrcFragExtraOut  += THE_VARY_TexCoord_IN;
1554       aSrcVertExtraMain += THE_VARY_TexCoord_Trsf;
1555
1556       aSrcFragGetColor =
1557         EOL"vec4 getColor(void) { return occTexture2D(occSamplerBaseColor, TexCoord.st / TexCoord.w); }";
1558     }
1559     else if ((theBits & OpenGl_PO_TextureEnv) != 0)
1560     {
1561       aSrcVertExtraOut += THE_VARY_TexCoord_OUT;
1562       aSrcFragExtraOut += THE_VARY_TexCoord_IN;
1563
1564       aSrcVertExtraFunc = THE_FUNC_transformNormal;
1565
1566       aSrcVertExtraMain +=
1567         EOL"  vec4 aPosition = occWorldViewMatrix * occModelWorldMatrix * occVertex;"
1568         EOL"  vec3 aNormal   = transformNormal (occNormal);"
1569         EOL"  vec3 aReflect  = reflect (normalize (aPosition.xyz), aNormal);"
1570         EOL"  aReflect.z += 1.0;"
1571         EOL"  TexCoord = vec4(aReflect.xy * inversesqrt (dot (aReflect, aReflect)) * 0.5 + vec2 (0.5), 0.0, 1.0);";
1572
1573       aSrcFragGetColor =
1574         EOL"vec4 getColor(void) { return occTexture2D (occSamplerBaseColor, TexCoord.st); }";
1575     }
1576   }
1577   if ((theBits & OpenGl_PO_VertColor) != 0)
1578   {
1579     aSrcVertExtraOut  += EOL"THE_SHADER_OUT vec4 VertColor;";
1580     aSrcVertExtraMain += EOL"  VertColor = occVertColor;";
1581     aSrcFragExtraOut  += EOL"THE_SHADER_IN  vec4 VertColor;";
1582     aSrcFragGetColor  =  EOL"vec4 getColor(void) { return VertColor; }";
1583   }
1584
1585   int aNbClipPlanes = 0;
1586   if ((theBits & OpenGl_PO_ClipPlanesN) != 0)
1587   {
1588     aSrcVertExtraOut +=
1589       EOL"THE_SHADER_OUT vec4 PositionWorld;"
1590       EOL"THE_SHADER_OUT vec4 Position;";
1591     aSrcFragExtraOut +=
1592       EOL"THE_SHADER_IN  vec4 PositionWorld;"
1593       EOL"THE_SHADER_IN  vec4 Position;";
1594     aSrcVertExtraMain +=
1595       EOL"  PositionWorld = occModelWorldMatrix * occVertex;"
1596       EOL"  Position      = occWorldViewMatrix * PositionWorld;";
1597
1598     if ((theBits & OpenGl_PO_ClipPlanes1) != 0)
1599     {
1600       aNbClipPlanes = 1;
1601       aSrcFragExtraMain += THE_FRAG_CLIP_PLANES_1;
1602     }
1603     else if ((theBits & OpenGl_PO_ClipPlanes2) != 0)
1604     {
1605       aNbClipPlanes = 2;
1606       aSrcFragExtraMain += (theBits & OpenGl_PO_ClipChains) != 0
1607                          ? THE_FRAG_CLIP_CHAINS_2
1608                          : THE_FRAG_CLIP_PLANES_2;
1609     }
1610     else
1611     {
1612       aNbClipPlanes = Graphic3d_ShaderProgram::THE_MAX_CLIP_PLANES_DEFAULT;
1613       aSrcFragExtraMain += (theBits & OpenGl_PO_ClipChains) != 0
1614                           ? THE_FRAG_CLIP_CHAINS_N
1615                           : THE_FRAG_CLIP_PLANES_N;
1616     }
1617   }
1618   if ((theBits & OpenGl_PO_WriteOit) != 0)
1619   {
1620     aProgramSrc->SetNbFragmentOutputs (2);
1621     aProgramSrc->SetWeightOitOutput (true);
1622   #if defined(GL_ES_VERSION_2_0)
1623     if (myContext->IsGlGreaterEqual (3, 0))
1624     {
1625       aProgramSrc->SetHeader ("#version 300 es");
1626     }
1627   #endif
1628   }
1629
1630   TCollection_AsciiString aSrcVertEndMain;
1631   if ((theBits & OpenGl_PO_StippleLine) != 0)
1632   {
1633     bool hasGlslBitOps = false;
1634   #if defined(GL_ES_VERSION_2_0)
1635     if (myContext->IsGlGreaterEqual (3, 0))
1636     {
1637       aProgramSrc->SetHeader ("#version 300 es");
1638       hasGlslBitOps = true;
1639     }
1640   #else
1641     if (myContext->IsGlGreaterEqual (3, 0))
1642     {
1643       aProgramSrc->SetHeader ("#version 130");
1644       hasGlslBitOps = true;
1645     }
1646     else if(myContext->CheckExtension("GL_EXT_gpu_shader4"))
1647     {
1648       aProgramSrc->SetHeader ("#extension GL_EXT_gpu_shader4 : enable");
1649       hasGlslBitOps = true;
1650     }
1651   #endif
1652
1653     if (hasGlslBitOps)
1654     {
1655       aSrcVertExtraOut +=
1656         EOL"THE_SHADER_OUT vec2 ScreenSpaceCoord;";
1657       aSrcFragExtraOut +=
1658         EOL"THE_SHADER_IN  vec2 ScreenSpaceCoord;"
1659         EOL"uniform int   uPattern;"
1660         EOL"uniform float uFactor;";
1661       aSrcVertEndMain =
1662         EOL"  ScreenSpaceCoord = gl_Position.xy / gl_Position.w;";
1663       aSrcFragMainGetColor =
1664         EOL"  float anAngle      = atan (dFdx (ScreenSpaceCoord.x), dFdy (ScreenSpaceCoord.y));"
1665         EOL"  float aRotatePoint = gl_FragCoord.x * sin (anAngle) + gl_FragCoord.y * cos (anAngle);"
1666         EOL"  uint  aBit         = uint (floor (aRotatePoint / uFactor + 0.5)) & 15U;"
1667         EOL"  if ((uint (uPattern) & (1U << aBit)) == 0U) discard;"
1668         EOL"  vec4 aColor = getColor();"
1669         EOL"  if (aColor.a <= 0.1) discard;"
1670         EOL"  occSetFragColor (aColor);";
1671     }
1672     else
1673     {
1674       const TCollection_ExtendedString aWarnMessage =
1675         "Warning: stipple lines in GLSL will be ignored.";
1676       myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION,
1677         GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_HIGH, aWarnMessage);
1678     }
1679   }
1680
1681   aSrcVert =
1682       aSrcVertExtraFunc
1683     + aSrcVertExtraOut
1684     + EOL"void main()"
1685       EOL"{"
1686     + aSrcVertExtraMain
1687     + EOL"  gl_Position = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix * occVertex;"
1688     + aSrcVertEndMain
1689     + EOL"}";
1690
1691   aSrcFrag =
1692       aSrcFragExtraOut
1693     + aSrcFragGetColor
1694     + aSrcGetAlpha
1695     + EOL"void main()"
1696       EOL"{"
1697     + aSrcFragExtraMain
1698     + aSrcFragMainGetColor
1699     + aSrcFragWriteOit
1700     + EOL"}";
1701
1702 #if !defined(GL_ES_VERSION_2_0)
1703   if (myContext->core32 != NULL)
1704   {
1705     aProgramSrc->SetHeader ("#version 150");
1706   }
1707 #else
1708   if (myContext->IsGlGreaterEqual (3, 1))
1709   {
1710     // prefer "100 es" on OpenGL ES 3.0 devices
1711     // and    "300 es" on newer devices (3.1+)
1712     aProgramSrc->SetHeader ("#version 300 es");
1713   }
1714 #endif
1715   aProgramSrc->SetNbLightsMax (0);
1716   aProgramSrc->SetNbClipPlanesMax (aNbClipPlanes);
1717   aProgramSrc->SetAlphaTest ((theBits & OpenGl_PO_AlphaTest) != 0);
1718   aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_VERTEX,   aSrcVert));
1719   aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_FRAGMENT, aSrcFrag));
1720
1721   TCollection_AsciiString aKey;
1722   if (!Create (aProgramSrc, aKey, theProgram))
1723   {
1724     theProgram = new OpenGl_ShaderProgram(); // just mark as invalid
1725     return Standard_False;
1726   }
1727   return Standard_True;
1728 }
1729
1730 // =======================================================================
1731 // function : pointSpriteShadingSrc
1732 // purpose  :
1733 // =======================================================================
1734 TCollection_AsciiString OpenGl_ShaderManager::pointSpriteShadingSrc (const TCollection_AsciiString theBaseColorSrc,
1735                                                                      const Standard_Integer theBits)
1736 {
1737   TCollection_AsciiString aSrcFragGetColor;
1738   if ((theBits & OpenGl_PO_TextureA) != 0)
1739   {
1740     aSrcFragGetColor = pointSpriteAlphaSrc (theBits) +
1741       EOL"vec4 getColor(void)"
1742       EOL"{"
1743       EOL"  vec4 aColor = " + theBaseColorSrc + ";"
1744       EOL"  aColor.a = getAlpha();"
1745       EOL"  if (aColor.a <= 0.1) discard;"
1746       EOL"  return aColor;"
1747       EOL"}";
1748   }
1749   else if ((theBits & OpenGl_PO_TextureRGB) != 0)
1750   {
1751     aSrcFragGetColor = TCollection_AsciiString() +
1752       EOL"vec4 getColor(void)"
1753       EOL"{"
1754       EOL"  vec4 aColor = " + theBaseColorSrc + ";"
1755       EOL"  aColor = occTexture2D(occSamplerBaseColor, " THE_VEC2_glPointCoord ") * aColor;"
1756       EOL"  if (aColor.a <= 0.1) discard;"
1757       EOL"  return aColor;"
1758       EOL"}";
1759   }
1760
1761   return aSrcFragGetColor;
1762 }
1763
1764 // =======================================================================
1765 // function : stdComputeLighting
1766 // purpose  :
1767 // =======================================================================
1768 TCollection_AsciiString OpenGl_ShaderManager::stdComputeLighting (Standard_Integer& theNbLights,
1769                                                                   Standard_Boolean  theHasVertColor)
1770 {
1771   TCollection_AsciiString aLightsFunc, aLightsLoop;
1772   theNbLights = 0;
1773   const Handle(Graphic3d_LightSet)& aLights = myLightSourceState.LightSources();
1774   if (!aLights.IsNull())
1775   {
1776     theNbLights = aLights->NbEnabled();
1777     if (theNbLights <= THE_NB_UNROLLED_LIGHTS_MAX)
1778     {
1779       Standard_Integer anIndex = 0;
1780       for (Graphic3d_LightSet::Iterator aLightIter (aLights, Graphic3d_LightSet::IterationFilter_ExcludeDisabledAndAmbient);
1781            aLightIter.More(); aLightIter.Next(), ++anIndex)
1782       {
1783         switch (aLightIter.Value()->Type())
1784         {
1785           case Graphic3d_TOLS_AMBIENT:
1786             --anIndex;
1787             break; // skip ambient
1788           case Graphic3d_TOLS_DIRECTIONAL:
1789             aLightsLoop = aLightsLoop + EOL"    directionalLight (" + anIndex + ", theNormal, theView, theIsFront);";
1790             break;
1791           case Graphic3d_TOLS_POSITIONAL:
1792             aLightsLoop = aLightsLoop + EOL"    pointLight (" + anIndex + ", theNormal, theView, aPoint, theIsFront);";
1793             break;
1794           case Graphic3d_TOLS_SPOT:
1795             aLightsLoop = aLightsLoop + EOL"    spotLight (" + anIndex + ", theNormal, theView, aPoint, theIsFront);";
1796             break;
1797         }
1798       }
1799     }
1800     else
1801     {
1802       theNbLights = roundUpMaxLightSources (theNbLights);
1803       bool isFirstInLoop = true;
1804       aLightsLoop = aLightsLoop +
1805         EOL"    for (int anIndex = 0; anIndex < occLightSourcesCount; ++anIndex)"
1806         EOL"    {"
1807         EOL"      int aType = occLight_Type (anIndex);";
1808       if (aLights->NbEnabledLightsOfType (Graphic3d_TOLS_DIRECTIONAL) > 0)
1809       {
1810         isFirstInLoop = false;
1811         aLightsLoop +=
1812           EOL"      if (aType == OccLightType_Direct)"
1813           EOL"      {"
1814           EOL"        directionalLight (anIndex, theNormal, theView, theIsFront);"
1815           EOL"      }";
1816       }
1817       if (aLights->NbEnabledLightsOfType (Graphic3d_TOLS_POSITIONAL) > 0)
1818       {
1819         if (!isFirstInLoop)
1820         {
1821           aLightsLoop += EOL"      else ";
1822         }
1823         isFirstInLoop = false;
1824         aLightsLoop +=
1825           EOL"      if (aType == OccLightType_Point)"
1826           EOL"      {"
1827           EOL"        pointLight (anIndex, theNormal, theView, aPoint, theIsFront);"
1828           EOL"      }";
1829       }
1830       if (aLights->NbEnabledLightsOfType (Graphic3d_TOLS_SPOT) > 0)
1831       {
1832         if (!isFirstInLoop)
1833         {
1834           aLightsLoop += EOL"      else ";
1835         }
1836         isFirstInLoop = false;
1837         aLightsLoop +=
1838           EOL"      if (aType == OccLightType_Spot)"
1839           EOL"      {"
1840           EOL"        spotLight (anIndex, theNormal, theView, aPoint, theIsFront);"
1841           EOL"      }";
1842       }
1843       aLightsLoop += EOL"    }";
1844     }
1845     if (aLights->NbEnabledLightsOfType (Graphic3d_TOLS_DIRECTIONAL) == 1
1846      && theNbLights == 1)
1847     {
1848       // use the version with hard-coded first index
1849       aLightsLoop = EOL"    directionalLightFirst(theNormal, theView, theIsFront);";
1850       aLightsFunc += THE_FUNC_directionalLightFirst;
1851     }
1852     else if (aLights->NbEnabledLightsOfType (Graphic3d_TOLS_DIRECTIONAL) > 0)
1853     {
1854       aLightsFunc += THE_FUNC_directionalLight;
1855     }
1856     if (aLights->NbEnabledLightsOfType (Graphic3d_TOLS_POSITIONAL) > 0)
1857     {
1858       aLightsFunc += THE_FUNC_pointLight;
1859     }
1860     if (aLights->NbEnabledLightsOfType (Graphic3d_TOLS_SPOT) > 0)
1861     {
1862       aLightsFunc += THE_FUNC_spotLight;
1863     }
1864   }
1865
1866   TCollection_AsciiString aGetMatAmbient = "theIsFront ? occFrontMaterial_Ambient()  : occBackMaterial_Ambient();";
1867   TCollection_AsciiString aGetMatDiffuse = "theIsFront ? occFrontMaterial_Diffuse()  : occBackMaterial_Diffuse();";
1868   if (theHasVertColor)
1869   {
1870     aGetMatAmbient = "getVertColor();";
1871     aGetMatDiffuse = "getVertColor();";
1872   }
1873
1874   return TCollection_AsciiString()
1875     + THE_FUNC_lightDef
1876     + aLightsFunc
1877     + EOL
1878       EOL"vec4 computeLighting (in vec3 theNormal,"
1879       EOL"                      in vec3 theView,"
1880       EOL"                      in vec4 thePoint,"
1881       EOL"                      in bool theIsFront)"
1882       EOL"{"
1883       EOL"  Ambient  = occLightAmbient.rgb;"
1884       EOL"  Diffuse  = vec3 (0.0);"
1885       EOL"  Specular = vec3 (0.0);"
1886       EOL"  vec3 aPoint = thePoint.xyz / thePoint.w;"
1887     + aLightsLoop
1888     + EOL"  vec4 aMatAmbient  = " + aGetMatAmbient
1889     + EOL"  vec4 aMatDiffuse  = " + aGetMatDiffuse
1890     + EOL"  vec4 aMatSpecular = theIsFront ? occFrontMaterial_Specular() : occBackMaterial_Specular();"
1891       EOL"  vec4 aMatEmission = theIsFront ? occFrontMaterial_Emission() : occBackMaterial_Emission();"
1892       EOL"  vec3 aColor = Ambient  * aMatAmbient.rgb"
1893       EOL"              + Diffuse  * aMatDiffuse.rgb"
1894       EOL"              + Specular * aMatSpecular.rgb"
1895       EOL"                         + aMatEmission.rgb;"
1896       EOL"  return vec4 (aColor, aMatDiffuse.a);"
1897       EOL"}";
1898 }
1899
1900 // =======================================================================
1901 // function : prepareStdProgramGouraud
1902 // purpose  :
1903 // =======================================================================
1904 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramGouraud (Handle(OpenGl_ShaderProgram)& theProgram,
1905                                                                  const Standard_Integer        theBits)
1906 {
1907   Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
1908   TCollection_AsciiString aSrcVert, aSrcVertColor, aSrcVertExtraOut, aSrcVertExtraMain;
1909   TCollection_AsciiString aSrcFrag, aSrcFragExtraOut, aSrcFragExtraMain, aSrcFragWriteOit;
1910   TCollection_AsciiString aSrcFragGetColor = EOL"vec4 getColor(void) { return gl_FrontFacing ? FrontColor : BackColor; }";
1911   if ((theBits & OpenGl_PO_Point) != 0)
1912   {
1913   #if defined(GL_ES_VERSION_2_0)
1914     aSrcVertExtraMain += EOL"  gl_PointSize = occPointSize;";
1915   #endif
1916
1917     if (textureUsed (theBits))
1918     {
1919       #if !defined(GL_ES_VERSION_2_0)
1920         if (myContext->core11 != NULL
1921          && myContext->IsGlGreaterEqual (2, 1))
1922         {
1923           aProgramSrc->SetHeader ("#version 120"); // gl_PointCoord has been added since GLSL 1.2
1924         }
1925       #endif
1926
1927       aSrcFragGetColor = pointSpriteShadingSrc ("gl_FrontFacing ? FrontColor : BackColor", theBits);
1928     }
1929   }
1930   else
1931   {
1932     if ((theBits & OpenGl_PO_TextureRGB) != 0)
1933     {
1934       aSrcVertExtraOut  += THE_VARY_TexCoord_OUT;
1935       aSrcFragExtraOut  += THE_VARY_TexCoord_IN;
1936       aSrcVertExtraMain += THE_VARY_TexCoord_Trsf;
1937
1938       aSrcFragGetColor =
1939         EOL"vec4 getColor(void)"
1940         EOL"{"
1941         EOL"  vec4 aColor = gl_FrontFacing ? FrontColor : BackColor;"
1942         EOL"  return occTexture2D(occSamplerBaseColor, TexCoord.st / TexCoord.w) * aColor;"
1943         EOL"}";
1944     }
1945   }
1946
1947   if ((theBits & OpenGl_PO_VertColor) != 0)
1948   {
1949     aSrcVertColor = EOL"vec4 getVertColor(void) { return occVertColor; }";
1950   }
1951
1952   int aNbClipPlanes = 0;
1953   if ((theBits & OpenGl_PO_ClipPlanesN) != 0)
1954   {
1955     aSrcVertExtraOut +=
1956       EOL"THE_SHADER_OUT vec4 PositionWorld;"
1957       EOL"THE_SHADER_OUT vec4 Position;";
1958     aSrcFragExtraOut +=
1959       EOL"THE_SHADER_IN  vec4 PositionWorld;"
1960       EOL"THE_SHADER_IN  vec4 Position;";
1961     aSrcVertExtraMain +=
1962       EOL"  PositionWorld = aPositionWorld;"
1963       EOL"  Position      = aPosition;";
1964
1965     if ((theBits & OpenGl_PO_ClipPlanes1) != 0)
1966     {
1967       aNbClipPlanes = 1;
1968       aSrcFragExtraMain += THE_FRAG_CLIP_PLANES_1;
1969     }
1970     else if ((theBits & OpenGl_PO_ClipPlanes2) != 0)
1971     {
1972       aNbClipPlanes = 2;
1973       aSrcFragExtraMain += (theBits & OpenGl_PO_ClipChains) != 0
1974                           ? THE_FRAG_CLIP_CHAINS_2
1975                           : THE_FRAG_CLIP_PLANES_2;
1976     }
1977     else
1978     {
1979       aNbClipPlanes = Graphic3d_ShaderProgram::THE_MAX_CLIP_PLANES_DEFAULT;
1980       aSrcFragExtraMain += (theBits & OpenGl_PO_ClipChains) != 0
1981                          ? THE_FRAG_CLIP_CHAINS_N
1982                          : THE_FRAG_CLIP_PLANES_N;
1983     }
1984   }
1985   if ((theBits & OpenGl_PO_WriteOit) != 0)
1986   {
1987     aProgramSrc->SetNbFragmentOutputs (2);
1988     aProgramSrc->SetWeightOitOutput (true);
1989   #if defined(GL_ES_VERSION_2_0)
1990     if (myContext->IsGlGreaterEqual (3, 0))
1991     {
1992       aProgramSrc->SetHeader ("#version 300 es");
1993     }
1994   #endif
1995   }
1996
1997   Standard_Integer aNbLights = 0;
1998   const TCollection_AsciiString aLights = stdComputeLighting (aNbLights, (theBits & OpenGl_PO_VertColor) != 0);
1999   aSrcVert = TCollection_AsciiString()
2000     + THE_FUNC_transformNormal
2001     + EOL
2002     + aSrcVertColor
2003     + aLights
2004     + EOL
2005       EOL"THE_SHADER_OUT vec4 FrontColor;"
2006       EOL"THE_SHADER_OUT vec4 BackColor;"
2007       EOL
2008     + aSrcVertExtraOut
2009     + EOL"void main()"
2010       EOL"{"
2011       EOL"  vec4 aPositionWorld = occModelWorldMatrix * occVertex;"
2012       EOL"  vec4 aPosition      = occWorldViewMatrix * aPositionWorld;"
2013       EOL"  vec3 aNormal        = transformNormal (occNormal);"
2014       EOL"  vec3 aView          = vec3 (0.0, 0.0, 1.0);"
2015       EOL"  FrontColor  = computeLighting (normalize (aNormal), normalize (aView), aPosition, true);"
2016       EOL"  BackColor   = computeLighting (normalize (aNormal), normalize (aView), aPosition, false);"
2017     + aSrcVertExtraMain
2018     + EOL"  gl_Position = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix * occVertex;"
2019       EOL"}";
2020
2021   aSrcFrag = TCollection_AsciiString()
2022     + EOL"THE_SHADER_IN vec4 FrontColor;"
2023       EOL"THE_SHADER_IN vec4 BackColor;"
2024     + aSrcFragExtraOut
2025     + aSrcFragGetColor
2026     + EOL"void main()"
2027       EOL"{"
2028     + aSrcFragExtraMain
2029     + EOL"  occSetFragColor (getColor());"
2030     + aSrcFragWriteOit
2031     + EOL"}";
2032
2033 #if !defined(GL_ES_VERSION_2_0)
2034   if (myContext->core32 != NULL)
2035   {
2036     aProgramSrc->SetHeader ("#version 150");
2037   }
2038 #else
2039   if (myContext->IsGlGreaterEqual (3, 1))
2040   {
2041     // prefer "100 es" on OpenGL ES 3.0 devices
2042     // and    "300 es" on newer devices (3.1+)
2043     aProgramSrc->SetHeader ("#version 300 es");
2044   }
2045 #endif
2046   aProgramSrc->SetNbLightsMax (aNbLights);
2047   aProgramSrc->SetNbClipPlanesMax (aNbClipPlanes);
2048   aProgramSrc->SetAlphaTest ((theBits & OpenGl_PO_AlphaTest) != 0);
2049   aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_VERTEX,   aSrcVert));
2050   aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_FRAGMENT, aSrcFrag));
2051   TCollection_AsciiString aKey;
2052   if (!Create (aProgramSrc, aKey, theProgram))
2053   {
2054     theProgram = new OpenGl_ShaderProgram(); // just mark as invalid
2055     return Standard_False;
2056   }
2057   return Standard_True;
2058 }
2059
2060 // =======================================================================
2061 // function : prepareStdProgramPhong
2062 // purpose  :
2063 // =======================================================================
2064 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramPhong (Handle(OpenGl_ShaderProgram)& theProgram,
2065                                                                const Standard_Integer        theBits,
2066                                                                const Standard_Boolean        theIsFlatNormal)
2067 {
2068   #define thePhongCompLight "computeLighting (normalize (Normal), normalize (View), Position, gl_FrontFacing)"
2069 #if defined(GL_ES_VERSION_2_0)
2070   const bool isFlatNormal = theIsFlatNormal
2071                          && (myContext->IsGlGreaterEqual (3, 0)
2072                           || myContext->oesStdDerivatives);
2073 #else
2074   const bool isFlatNormal = theIsFlatNormal;
2075 #endif
2076
2077   Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
2078   TCollection_AsciiString aSrcVert, aSrcVertExtraOut, aSrcVertExtraMain;
2079   TCollection_AsciiString aSrcFrag, aSrcFragExtraOut, aSrcFragGetVertColor, aSrcFragExtraMain, aSrcFragWriteOit;
2080   TCollection_AsciiString aSrcFragGetColor = EOL"vec4 getColor(void) { return " thePhongCompLight "; }";
2081   if ((theBits & OpenGl_PO_Point) != 0)
2082   {
2083   #if defined(GL_ES_VERSION_2_0)
2084     aSrcVertExtraMain += EOL"  gl_PointSize = occPointSize;";
2085   #endif
2086
2087     if (textureUsed (theBits))
2088     {
2089       #if !defined(GL_ES_VERSION_2_0)
2090         if (myContext->core11 != NULL
2091          && myContext->IsGlGreaterEqual (2, 1))
2092         {
2093           aProgramSrc->SetHeader ("#version 120"); // gl_PointCoord has been added since GLSL 1.2
2094         }
2095       #endif
2096
2097       aSrcFragGetColor = pointSpriteShadingSrc (thePhongCompLight, theBits);
2098     }
2099   }
2100   else
2101   {
2102     if ((theBits & OpenGl_PO_TextureRGB) != 0)
2103     {
2104       aSrcVertExtraOut  += THE_VARY_TexCoord_OUT;
2105       aSrcFragExtraOut  += THE_VARY_TexCoord_IN;
2106       aSrcVertExtraMain += THE_VARY_TexCoord_Trsf;
2107
2108       aSrcFragGetColor =
2109         EOL"vec4 getColor(void)"
2110         EOL"{"
2111         EOL"  vec4 aColor = " thePhongCompLight ";"
2112         EOL"  return occTexture2D(occSamplerBaseColor, TexCoord.st / TexCoord.w) * aColor;"
2113         EOL"}";
2114     }
2115   }
2116
2117   if ((theBits & OpenGl_PO_VertColor) != 0)
2118   {
2119     aSrcVertExtraOut    += EOL"THE_SHADER_OUT vec4 VertColor;";
2120     aSrcVertExtraMain   += EOL"  VertColor = occVertColor;";
2121     aSrcFragGetVertColor = EOL"THE_SHADER_IN  vec4 VertColor;"
2122                            EOL"vec4 getVertColor(void) { return VertColor; }";
2123   }
2124
2125   int aNbClipPlanes = 0;
2126   if ((theBits & OpenGl_PO_ClipPlanesN) != 0)
2127   {
2128     if ((theBits & OpenGl_PO_ClipPlanes1) != 0)
2129     {
2130       aNbClipPlanes = 1;
2131       aSrcFragExtraMain += THE_FRAG_CLIP_PLANES_1;
2132     }
2133     else if ((theBits & OpenGl_PO_ClipPlanes2) != 0)
2134     {
2135       aNbClipPlanes = 2;
2136       aSrcFragExtraMain += (theBits & OpenGl_PO_ClipChains) != 0
2137                          ? THE_FRAG_CLIP_CHAINS_2
2138                          : THE_FRAG_CLIP_PLANES_2;
2139     }
2140     else
2141     {
2142       aNbClipPlanes = Graphic3d_ShaderProgram::THE_MAX_CLIP_PLANES_DEFAULT;
2143       aSrcFragExtraMain += (theBits & OpenGl_PO_ClipChains) != 0
2144                          ? THE_FRAG_CLIP_CHAINS_N
2145                          : THE_FRAG_CLIP_PLANES_N;
2146     }
2147   }
2148   if ((theBits & OpenGl_PO_WriteOit) != 0)
2149   {
2150     aProgramSrc->SetNbFragmentOutputs (2);
2151     aProgramSrc->SetWeightOitOutput (true);
2152   }
2153
2154   aSrcVert = TCollection_AsciiString()
2155     + (isFlatNormal ? "" : THE_FUNC_transformNormal)
2156     + EOL
2157       EOL"THE_SHADER_OUT vec4 PositionWorld;"
2158       EOL"THE_SHADER_OUT vec4 Position;"
2159       EOL"THE_SHADER_OUT vec3 View;"
2160     + (isFlatNormal ? ""
2161     : EOL"THE_SHADER_OUT vec3 Normal;")
2162     + EOL
2163     + aSrcVertExtraOut
2164     + EOL"void main()"
2165       EOL"{"
2166       EOL"  PositionWorld = occModelWorldMatrix * occVertex;"
2167       EOL"  Position      = occWorldViewMatrix * PositionWorld;"
2168     + (isFlatNormal ? ""
2169     : EOL"  Normal        = transformNormal (occNormal);")
2170     + EOL"  View          = vec3 (0.0, 0.0, 1.0);"
2171     + aSrcVertExtraMain
2172     + EOL"  gl_Position = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix * occVertex;"
2173       EOL"}";
2174
2175   Standard_Integer aNbLights = 0;
2176   const TCollection_AsciiString aLights = stdComputeLighting (aNbLights, (theBits & OpenGl_PO_VertColor) != 0);
2177   aSrcFrag = TCollection_AsciiString()
2178     + EOL"THE_SHADER_IN vec4 PositionWorld;"
2179       EOL"THE_SHADER_IN vec4 Position;"
2180       EOL"THE_SHADER_IN vec3 View;"
2181     + (isFlatNormal
2182     ? EOL"vec3 Normal;"
2183     : EOL"THE_SHADER_IN vec3 Normal;")
2184     + EOL
2185     + aSrcFragExtraOut
2186     + aSrcFragGetVertColor
2187     + aLights
2188     + aSrcFragGetColor
2189     + EOL
2190       EOL"void main()"
2191       EOL"{"
2192     + aSrcFragExtraMain
2193     + (isFlatNormal
2194     ? EOL"  Normal = normalize (cross (dFdx (Position.xyz / Position.w), dFdy (Position.xyz / Position.w)));"
2195       EOL"  if (!gl_FrontFacing) { Normal = -Normal; }"
2196     : "")
2197     + EOL"  occSetFragColor (getColor());"
2198     + aSrcFragWriteOit
2199     + EOL"}";
2200
2201 #if !defined(GL_ES_VERSION_2_0)
2202   if (myContext->core32 != NULL)
2203   {
2204     aProgramSrc->SetHeader ("#version 150");
2205   }
2206 #else
2207   if (myContext->IsGlGreaterEqual (3, 1))
2208   {
2209     // prefer "100 es" on OpenGL ES 3.0 devices
2210     // and    "300 es" on newer devices (3.1+)
2211     aProgramSrc->SetHeader ("#version 300 es");
2212   }
2213   else if (isFlatNormal)
2214   {
2215     if (myContext->IsGlGreaterEqual (3, 0))
2216     {
2217       aProgramSrc->SetHeader ("#version 300 es");
2218     }
2219     else if (myContext->oesStdDerivatives)
2220     {
2221       aProgramSrc->SetHeader ("#extension GL_OES_standard_derivatives : enable");
2222     }
2223     else
2224     {
2225       myContext->PushMessage (GL_DEBUG_SOURCE_APPLICATION,
2226                               GL_DEBUG_TYPE_PORTABILITY, 0, GL_DEBUG_SEVERITY_MEDIUM,
2227                               "Warning: flat shading requires OpenGL ES 3.0+ or GL_OES_standard_derivatives extension.");
2228     }
2229   }
2230 #endif
2231   aProgramSrc->SetNbLightsMax (aNbLights);
2232   aProgramSrc->SetNbClipPlanesMax (aNbClipPlanes);
2233   aProgramSrc->SetAlphaTest ((theBits & OpenGl_PO_AlphaTest) != 0);
2234   aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_VERTEX,   aSrcVert));
2235   aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_FRAGMENT, aSrcFrag));
2236   TCollection_AsciiString aKey;
2237   if (!Create (aProgramSrc, aKey, theProgram))
2238   {
2239     theProgram = new OpenGl_ShaderProgram(); // just mark as invalid
2240     return Standard_False;
2241   }
2242   return Standard_True;
2243 }
2244
2245 // =======================================================================
2246 // function : prepareStdProgramStereo
2247 // purpose  :
2248 // =======================================================================
2249 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramStereo (Handle(OpenGl_ShaderProgram)& theProgram,
2250                                                                 const Graphic3d_StereoMode    theStereoMode)
2251 {
2252   Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
2253   TCollection_AsciiString aSrcVert =
2254       EOL"THE_SHADER_OUT vec2 TexCoord;"
2255       EOL"void main()"
2256       EOL"{"
2257       EOL"  TexCoord    = occVertex.zw;"
2258       EOL"  gl_Position = vec4(occVertex.x, occVertex.y, 0.0, 1.0);"
2259       EOL"}";
2260
2261   TCollection_AsciiString aSrcFrag;
2262   switch (theStereoMode)
2263   {
2264     case Graphic3d_StereoMode_Anaglyph:
2265     {
2266       aSrcFrag =
2267           EOL"uniform sampler2D uLeftSampler;"
2268           EOL"uniform sampler2D uRightSampler;"
2269           EOL
2270           EOL"uniform mat4 uMultL;"
2271           EOL"uniform mat4 uMultR;"
2272           EOL
2273           EOL"const vec4 THE_POW_UP   =       vec4 (2.2, 2.2, 2.2, 1.0);"
2274           EOL"const vec4 THE_POW_DOWN = 1.0 / vec4 (2.2, 2.2, 2.2, 1.0);"
2275           EOL
2276           EOL"THE_SHADER_IN vec2 TexCoord;"
2277           EOL
2278           EOL"void main()"
2279           EOL"{"
2280           EOL"  vec4 aColorL = occTexture2D (uLeftSampler,  TexCoord);"
2281           EOL"  vec4 aColorR = occTexture2D (uRightSampler, TexCoord);"
2282           EOL"  aColorL = pow (aColorL, THE_POW_UP);" // normalize
2283           EOL"  aColorR = pow (aColorR, THE_POW_UP);"
2284           EOL"  vec4 aColor = uMultR * aColorR + uMultL * aColorL;"
2285           EOL"  occSetFragColor (pow (aColor, THE_POW_DOWN));"
2286           EOL"}";
2287       break;
2288     }
2289     case Graphic3d_StereoMode_RowInterlaced:
2290     {
2291       aSrcFrag =
2292           EOL"uniform sampler2D uLeftSampler;"
2293           EOL"uniform sampler2D uRightSampler;"
2294           EOL
2295           EOL"THE_SHADER_IN vec2 TexCoord;"
2296           EOL
2297           EOL"void main()"
2298           EOL"{"
2299           EOL"  vec4 aColorL = occTexture2D (uLeftSampler,  TexCoord);"
2300           EOL"  vec4 aColorR = occTexture2D (uRightSampler, TexCoord);"
2301           EOL"  if (int (mod (gl_FragCoord.y - 1023.5, 2.0)) != 1)"
2302           EOL"  {"
2303           EOL"    occSetFragColor (aColorL);"
2304           EOL"  }"
2305           EOL"  else"
2306           EOL"  {"
2307           EOL"    occSetFragColor (aColorR);"
2308           EOL"  }"
2309           EOL"}";
2310       break;
2311     }
2312     case Graphic3d_StereoMode_ColumnInterlaced:
2313     {
2314       aSrcFrag =
2315           EOL"uniform sampler2D uLeftSampler;"
2316           EOL"uniform sampler2D uRightSampler;"
2317           EOL
2318           EOL"THE_SHADER_IN vec2 TexCoord;"
2319           EOL
2320           EOL"void main()"
2321           EOL"{"
2322           EOL"  vec4 aColorL = occTexture2D (uLeftSampler,  TexCoord);"
2323           EOL"  vec4 aColorR = occTexture2D (uRightSampler, TexCoord);"
2324           EOL"  if (int (mod (gl_FragCoord.x - 1023.5, 2.0)) == 1)"
2325           EOL"  {"
2326           EOL"    occSetFragColor (aColorL);"
2327           EOL"  }"
2328           EOL"  else"
2329           EOL"  {"
2330           EOL"    occSetFragColor (aColorR);"
2331           EOL"  }"
2332           EOL"}";
2333       break;
2334     }
2335     case Graphic3d_StereoMode_ChessBoard:
2336     {
2337       aSrcFrag =
2338           EOL"uniform sampler2D uLeftSampler;"
2339           EOL"uniform sampler2D uRightSampler;"
2340           EOL
2341           EOL"THE_SHADER_IN vec2 TexCoord;"
2342           EOL
2343           EOL"void main()"
2344           EOL"{"
2345           EOL"  vec4 aColorL = occTexture2D (uLeftSampler,  TexCoord);"
2346           EOL"  vec4 aColorR = occTexture2D (uRightSampler, TexCoord);"
2347           EOL"  bool isEvenX = int(mod(floor(gl_FragCoord.x - 1023.5), 2.0)) != 1;"
2348           EOL"  bool isEvenY = int(mod(floor(gl_FragCoord.y - 1023.5), 2.0)) == 1;"
2349           EOL"  if ((isEvenX && isEvenY) || (!isEvenX && !isEvenY))"
2350           EOL"  {"
2351           EOL"    occSetFragColor (aColorL);"
2352           EOL"  }"
2353           EOL"  else"
2354           EOL"  {"
2355           EOL"    occSetFragColor (aColorR);"
2356           EOL"  }"
2357           EOL"}";
2358       break;
2359     }
2360     case Graphic3d_StereoMode_SideBySide:
2361     {
2362       aSrcFrag =
2363           EOL"uniform sampler2D uLeftSampler;"
2364           EOL"uniform sampler2D uRightSampler;"
2365           EOL
2366           EOL"THE_SHADER_IN vec2 TexCoord;"
2367           EOL
2368           EOL"void main()"
2369           EOL"{"
2370           EOL"  vec2 aTexCoord = vec2 (TexCoord.x * 2.0, TexCoord.y);"
2371           EOL"  if (TexCoord.x > 0.5)"
2372           EOL"  {"
2373           EOL"    aTexCoord.x -= 1.0;"
2374           EOL"  }"
2375           EOL"  vec4 aColorL = occTexture2D (uLeftSampler,  aTexCoord);"
2376           EOL"  vec4 aColorR = occTexture2D (uRightSampler, aTexCoord);"
2377           EOL"  if (TexCoord.x <= 0.5)"
2378           EOL"  {"
2379           EOL"    occSetFragColor (aColorL);"
2380           EOL"  }"
2381           EOL"  else"
2382           EOL"  {"
2383           EOL"    occSetFragColor (aColorR);"
2384           EOL"  }"
2385           EOL"}";
2386       break;
2387     }
2388     case Graphic3d_StereoMode_OverUnder:
2389     {
2390       aSrcFrag =
2391           EOL"uniform sampler2D uLeftSampler;"
2392           EOL"uniform sampler2D uRightSampler;"
2393           EOL
2394           EOL"THE_SHADER_IN vec2 TexCoord;"
2395           EOL
2396           EOL"void main()"
2397           EOL"{"
2398           EOL"  vec2 aTexCoord = vec2 (TexCoord.x, TexCoord.y * 2.0);"
2399           EOL"  if (TexCoord.y > 0.5)"
2400           EOL"  {"
2401           EOL"    aTexCoord.y -= 1.0;"
2402           EOL"  }"
2403           EOL"  vec4 aColorL = occTexture2D (uLeftSampler,  aTexCoord);"
2404           EOL"  vec4 aColorR = occTexture2D (uRightSampler, aTexCoord);"
2405           EOL"  if (TexCoord.y <= 0.5)"
2406           EOL"  {"
2407           EOL"    occSetFragColor (aColorL);"
2408           EOL"  }"
2409           EOL"  else"
2410           EOL"  {"
2411           EOL"    occSetFragColor (aColorR);"
2412           EOL"  }"
2413           EOL"}";
2414       break;
2415     }
2416     case Graphic3d_StereoMode_QuadBuffer:
2417     case Graphic3d_StereoMode_SoftPageFlip:
2418     default:
2419     {
2420       /*const Handle(OpenGl_ShaderProgram)& aProgram = myStereoPrograms[Graphic3d_StereoMode_QuadBuffer];
2421       if (!aProgram.IsNull())
2422       {
2423         return aProgram->IsValid();
2424       }*/
2425       aSrcFrag =
2426           EOL"uniform sampler2D uLeftSampler;"
2427           EOL"uniform sampler2D uRightSampler;"
2428           EOL
2429           EOL"THE_SHADER_IN vec2 TexCoord;"
2430           EOL
2431           EOL"void main()"
2432           EOL"{"
2433           EOL"  vec4 aColorL = occTexture2D (uLeftSampler,  TexCoord);"
2434           EOL"  vec4 aColorR = occTexture2D (uRightSampler, TexCoord);"
2435           EOL"  aColorL.b = 0.0;"
2436           EOL"  aColorL.g = 0.0;"
2437           EOL"  aColorR.r = 0.0;"
2438           EOL"  occSetFragColor (aColorL + aColorR);"
2439           EOL"}";
2440       break;
2441     }
2442   }
2443
2444 #if !defined(GL_ES_VERSION_2_0)
2445   if (myContext->core32 != NULL)
2446   {
2447     aProgramSrc->SetHeader ("#version 150");
2448   }
2449 #else
2450   if (myContext->IsGlGreaterEqual (3, 1))
2451   {
2452     // prefer "100 es" on OpenGL ES 3.0 devices
2453     // and    "300 es" on newer devices (3.1+)
2454     aProgramSrc->SetHeader ("#version 300 es");
2455   }
2456 #endif
2457
2458   aProgramSrc->SetNbLightsMax (0);
2459   aProgramSrc->SetNbClipPlanesMax (0);
2460   aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_VERTEX,   aSrcVert));
2461   aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_FRAGMENT, aSrcFrag));
2462   TCollection_AsciiString aKey;
2463   if (!Create (aProgramSrc, aKey, theProgram))
2464   {
2465     theProgram = new OpenGl_ShaderProgram(); // just mark as invalid
2466     return Standard_False;
2467   }
2468
2469   myContext->BindProgram (theProgram);
2470   theProgram->SetSampler (myContext, "uLeftSampler",  Graphic3d_TextureUnit_0);
2471   theProgram->SetSampler (myContext, "uRightSampler", Graphic3d_TextureUnit_1);
2472   myContext->BindProgram (NULL);
2473   return Standard_True;
2474 }
2475
2476 // =======================================================================
2477 // function : prepareStdProgramBoundBox
2478 // purpose  :
2479 // =======================================================================
2480 Standard_Boolean OpenGl_ShaderManager::prepareStdProgramBoundBox()
2481 {
2482   Handle(Graphic3d_ShaderProgram) aProgramSrc = new Graphic3d_ShaderProgram();
2483   TCollection_AsciiString aSrcVert =
2484     EOL"uniform vec3 occBBoxCenter;"
2485     EOL"uniform vec3 occBBoxSize;"
2486     EOL
2487     EOL"void main()"
2488     EOL"{"
2489     EOL"  vec4 aCenter = vec4(occVertex.xyz * occBBoxSize + occBBoxCenter, 1.0);"
2490     EOL"  vec4 aPos    = vec4(occVertex.xyz * occBBoxSize + occBBoxCenter, 1.0);"
2491     EOL"  gl_Position = occProjectionMatrix * occWorldViewMatrix * occModelWorldMatrix * aPos;"
2492     EOL"}";
2493
2494   TCollection_AsciiString aSrcFrag =
2495     EOL"void main()"
2496     EOL"{"
2497     EOL"  occSetFragColor (occColor);"
2498     EOL"}";
2499
2500 #if !defined(GL_ES_VERSION_2_0)
2501   if (myContext->core32 != NULL)
2502   {
2503     aProgramSrc->SetHeader ("#version 150");
2504   }
2505 #else
2506   if (myContext->IsGlGreaterEqual (3, 1))
2507   {
2508     // prefer "100 es" on OpenGL ES 3.0 devices
2509     // and    "300 es" on newer devices (3.1+)
2510     aProgramSrc->SetHeader ("#version 300 es");
2511   }
2512 #endif
2513
2514   aProgramSrc->SetNbLightsMax (0);
2515   aProgramSrc->SetNbClipPlanesMax (0);
2516   aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_VERTEX,   aSrcVert));
2517   aProgramSrc->AttachShader (Graphic3d_ShaderObject::CreateFromSource (Graphic3d_TOS_FRAGMENT, aSrcFrag));
2518   TCollection_AsciiString aKey;
2519   if (!Create (aProgramSrc, aKey, myBoundBoxProgram))
2520   {
2521     myBoundBoxProgram = new OpenGl_ShaderProgram(); // just mark as invalid
2522     return Standard_False;
2523   }
2524
2525   const OpenGl_Vec4 aMin (-0.5f, -0.5f, -0.5f, 1.0f);
2526   const OpenGl_Vec4 anAxisShifts[3] =
2527   {
2528     OpenGl_Vec4 (1.0f, 0.0f, 0.0f, 0.0f),
2529     OpenGl_Vec4 (0.0f, 1.0f, 0.0f, 0.0f),
2530     OpenGl_Vec4 (0.0f, 0.0f, 1.0f, 0.0f)
2531   };
2532
2533   const OpenGl_Vec4 aLookup1 (0.0f, 1.0f, 0.0f, 1.0f);
2534   const OpenGl_Vec4 aLookup2 (0.0f, 0.0f, 1.0f, 1.0f);
2535   OpenGl_Vec4 aLinesVertices[24];
2536   for (int anAxis = 0, aVertex = 0; anAxis < 3; ++anAxis)
2537   {
2538     for (int aCompIter = 0; aCompIter < 4; ++aCompIter)
2539     {
2540       aLinesVertices[aVertex++] = aMin
2541         + anAxisShifts[(anAxis + 1) % 3] * aLookup1[aCompIter]
2542         + anAxisShifts[(anAxis + 2) % 3] * aLookup2[aCompIter];
2543
2544       aLinesVertices[aVertex++] = aMin
2545         + anAxisShifts[anAxis]
2546         + anAxisShifts[(anAxis + 1) % 3] * aLookup1[aCompIter]
2547         + anAxisShifts[(anAxis + 2) % 3] * aLookup2[aCompIter];
2548     }
2549   }
2550   if (myContext->ToUseVbo())
2551   {
2552     myBoundBoxVertBuffer = new OpenGl_VertexBuffer();
2553     if (myBoundBoxVertBuffer->Init (myContext, 4, 24, aLinesVertices[0].GetData()))
2554     {
2555       myContext->ShareResource ("OpenGl_ShaderManager_BndBoxVbo", myBoundBoxVertBuffer);
2556       return Standard_True;
2557     }
2558   }
2559   myBoundBoxVertBuffer = new OpenGl_VertexBufferCompat();
2560   myBoundBoxVertBuffer->Init (myContext, 4, 24, aLinesVertices[0].GetData());
2561   myContext->ShareResource ("OpenGl_ShaderManager_BndBoxVbo", myBoundBoxVertBuffer);
2562   return Standard_True;
2563 }
2564
2565 // =======================================================================
2566 // function : bindProgramWithState
2567 // purpose  :
2568 // =======================================================================
2569 Standard_Boolean OpenGl_ShaderManager::bindProgramWithState (const Handle(OpenGl_ShaderProgram)& theProgram)
2570 {
2571   const Standard_Boolean isBound = myContext->BindProgram (theProgram);
2572   if (isBound
2573   && !theProgram.IsNull())
2574   {
2575     theProgram->ApplyVariables (myContext);
2576   }
2577   PushState (theProgram);
2578   return isBound;
2579 }