src/OpenGl/OpenGl_ShaderManager.hxx

   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 #ifndef _OpenGl_ShaderManager_HeaderFile
  17 #define _OpenGl_ShaderManager_HeaderFile
  18
  19 #include <Graphic3d_ShaderManager.hxx>
  20 #include <NCollection_Sequence.hxx>
  21 #include <OpenGl_PBREnvironment.hxx>
  22 #include <OpenGl_SetOfShaderPrograms.hxx>
  23 #include <OpenGl_ShaderStates.hxx>
  24 #include <OpenGl_Aspects.hxx>
  25 #include <OpenGl_MaterialState.hxx>
  26 #include <OpenGl_Texture.hxx>
  27
  28 class OpenGl_View;
  29 class OpenGl_VertexBuffer;
  30
  31 //! List of shader programs.
  32 typedef NCollection_Sequence<Handle(OpenGl_ShaderProgram)> OpenGl_ShaderProgramList;
  33
  34 //! This class is responsible for managing shader programs.
  35 class OpenGl_ShaderManager : public Graphic3d_ShaderManager
  36 {
  37   DEFINE_STANDARD_RTTIEXT(OpenGl_ShaderManager, Graphic3d_ShaderManager)
  38   friend class OpenGl_ShaderProgram;
  39 public:
  40
  41   //! Creates new empty shader manager.
  42   Standard_EXPORT OpenGl_ShaderManager (OpenGl_Context* theContext);
  43
  44   //! Releases resources of shader manager.
  45   Standard_EXPORT virtual ~OpenGl_ShaderManager();
  46
  47   //! Release all resources.
  48   Standard_EXPORT void clear();
  49
  50   //! Fetch sRGB state from caps and invalidates programs, if necessary.
  51   Standard_EXPORT void UpdateSRgbState();
  52
  53   //! Return local camera transformation.
  54   const gp_XYZ& LocalOrigin() const { return myLocalOrigin; }
  55
  56   //! Setup local camera transformation for compensating float precision issues.
  57   void SetLocalOrigin (const gp_XYZ& theOrigin)
  58   {
  59     myLocalOrigin    = theOrigin;
  60     myHasLocalOrigin = !theOrigin.IsEqual (gp_XYZ(0.0, 0.0, 0.0), gp::Resolution());
  61   }
  62
  63   //! Return clipping plane W equation value moved considering local camera transformation.
  64   Standard_Real LocalClippingPlaneW (const Graphic3d_ClipPlane& thePlane) const
  65   {
  66     const Graphic3d_Vec4d& anEq = thePlane.GetEquation();
  67     if (myHasLocalOrigin)
  68     {
  69       const gp_XYZ aPos = thePlane.ToPlane().Position().Location().XYZ() - myLocalOrigin;
  70       return -(anEq.x() * aPos.X() + anEq.y() * aPos.Y() + anEq.z() * aPos.Z());
  71     }
  72     return anEq.w();
  73   }
  74
  75   //! Creates new shader program or re-use shared instance.
  76   //! @param theProxy    [IN]  program definition
  77   //! @param theShareKey [OUT] sharing key
  78   //! @param theProgram  [OUT] OpenGL program
  79   //! @return true on success
  80   Standard_EXPORT Standard_Boolean Create (const Handle(Graphic3d_ShaderProgram)& theProxy,
  81                                            TCollection_AsciiString&               theShareKey,
  82                                            Handle(OpenGl_ShaderProgram)&          theProgram);
  83
  84   //! Unregisters specified shader program.
  85   Standard_EXPORT void Unregister (TCollection_AsciiString&      theShareKey,
  86                                    Handle(OpenGl_ShaderProgram)& theProgram);
  87
  88   //! Returns list of registered shader programs.
  89   const OpenGl_ShaderProgramList& ShaderPrograms() const { return myProgramList; }
  90
  91   //! Returns true if no program objects are registered in the manager.
  92   Standard_Boolean IsEmpty() const { return myProgramList.IsEmpty(); }
  93
  94   //! Bind program for filled primitives rendering
  95   Standard_Boolean BindFaceProgram (const Handle(OpenGl_TextureSet)& theTextures,
  96                                     Graphic3d_TypeOfShadingModel theShadingModel,
  97                                     Graphic3d_AlphaMode theAlphaMode,
  98                                     Standard_Boolean theHasVertColor,
  99                                     Standard_Boolean theEnableEnvMap,
 100                                     const Handle(OpenGl_ShaderProgram)& theCustomProgram)
 101   {
 102     return BindFaceProgram (theTextures, theShadingModel, theAlphaMode, Aspect_IS_SOLID,
 103                             theHasVertColor, theEnableEnvMap, false, theCustomProgram);
 104   }
 105
 106   //! Bind program for filled primitives rendering
 107   Standard_Boolean BindFaceProgram (const Handle(OpenGl_TextureSet)& theTextures,
 108                                     Graphic3d_TypeOfShadingModel theShadingModel,
 109                                     Graphic3d_AlphaMode theAlphaMode,
 110                                     Aspect_InteriorStyle theInteriorStyle,
 111                                     Standard_Boolean theHasVertColor,
 112                                     Standard_Boolean theEnableEnvMap,
 113                                     Standard_Boolean theEnableMeshEdges,
 114                                     const Handle(OpenGl_ShaderProgram)& theCustomProgram)
 115   {
 116     const Graphic3d_TypeOfShadingModel aShadeModelOnFace = theShadingModel != Graphic3d_TOSM_UNLIT
 117                                                         && (theTextures.IsNull() || theTextures->IsModulate())
 118                                                         ? theShadingModel
 119                                                         : Graphic3d_TOSM_UNLIT;
 120     if (!theCustomProgram.IsNull()
 121      || myContext->caps->ffpEnable)
 122     {
 123       return bindProgramWithState (theCustomProgram, aShadeModelOnFace);
 124     }
 125
 126     const Standard_Integer aBits = getProgramBits (theTextures, theAlphaMode, theInteriorStyle, theHasVertColor, theEnableEnvMap, theEnableMeshEdges);
 127     Handle(OpenGl_ShaderProgram)& aProgram = getStdProgram (aShadeModelOnFace, aBits);
 128     return bindProgramWithState (aProgram, aShadeModelOnFace);
 129   }
 130
 131   //! Bind program for line rendering
 132   Standard_Boolean BindLineProgram (const Handle(OpenGl_TextureSet)&    theTextures,
 133                                     const Aspect_TypeOfLine             theLineType,
 134                                     const Graphic3d_TypeOfShadingModel  theShadingModel,
 135                                     const Graphic3d_AlphaMode           theAlphaMode,
 136                                     const Standard_Boolean              theHasVertColor,
 137                                     const Handle(OpenGl_ShaderProgram)& theCustomProgram)
 138   {
 139     if (!theCustomProgram.IsNull()
 140      || myContext->caps->ffpEnable)
 141     {
 142       return bindProgramWithState (theCustomProgram, theShadingModel);
 143     }
 144
 145     Standard_Integer aBits = getProgramBits (theTextures, theAlphaMode, Aspect_IS_SOLID, theHasVertColor, false, false);
 146     if (theLineType != Aspect_TOL_SOLID)
 147     {
 148       aBits |= Graphic3d_ShaderFlags_StippleLine;
 149     }
 150
 151     Handle(OpenGl_ShaderProgram)& aProgram = getStdProgram (theShadingModel, aBits);
 152     return bindProgramWithState (aProgram, theShadingModel);
 153   }
 154
 155   //! Bind program for point rendering
 156   Standard_EXPORT Standard_Boolean BindMarkerProgram (const Handle(OpenGl_TextureSet)& theTextures,
 157                                                       Graphic3d_TypeOfShadingModel theShadingModel,
 158                                                       Graphic3d_AlphaMode theAlphaMode,
 159                                                       Standard_Boolean theHasVertColor,
 160                                                       const Handle(OpenGl_ShaderProgram)& theCustomProgram);
 161
 162   //! Bind program for rendering alpha-textured font.
 163   Standard_Boolean BindFontProgram (const Handle(OpenGl_ShaderProgram)& theCustomProgram);
 164
 165   //! Bind program for outline rendering
 166   Standard_Boolean BindOutlineProgram()
 167   {
 168     if (myContext->caps->ffpEnable)
 169     {
 170       return false;
 171     }
 172
 173     const Standard_Integer aBits = getProgramBits (Handle(OpenGl_TextureSet)(), Graphic3d_AlphaMode_Opaque, Aspect_IS_SOLID, false, false, false);
 174     if (myOutlinePrograms.IsNull())
 175     {
 176       myOutlinePrograms = new OpenGl_SetOfPrograms();
 177     }
 178     Handle(OpenGl_ShaderProgram)& aProgram = myOutlinePrograms->ChangeValue (aBits);
 179     if (aProgram.IsNull())
 180     {
 181       prepareStdProgramUnlit (aProgram, aBits, true);
 182     }
 183     return bindProgramWithState (aProgram, Graphic3d_TOSM_UNLIT);
 184   }
 185
 186   //! Bind program for FBO blit operation.
 187   //! @param theNbSamples       [in] number of samples within source MSAA texture
 188   //! @param theIsFallback_sRGB [in] flag indicating that destination buffer is not sRGB-ready
 189   Standard_EXPORT Standard_Boolean BindFboBlitProgram (Standard_Integer theNbSamples,
 190                                                        Standard_Boolean theIsFallback_sRGB);
 191
 192   //! Bind program for blended order-independent transparency buffers compositing.
 193   Standard_EXPORT Standard_Boolean BindOitCompositingProgram (Standard_Boolean theIsMSAAEnabled);
 194
 195   //! Bind program for Depth Peeling order-independent transparency back color blending.
 196   Standard_EXPORT Standard_Boolean BindOitDepthPeelingBlendProgram (bool theIsMSAAEnabled);
 197
 198   //! Bind program for Depth Peeling order-independent transparency flush.
 199   Standard_EXPORT Standard_Boolean BindOitDepthPeelingFlushProgram (bool theIsMSAAEnabled);
 200
 201   //! Bind program for rendering stereoscopic image.
 202   Standard_EXPORT Standard_Boolean BindStereoProgram (Graphic3d_StereoMode theStereoMode);
 203
 204   //! Bind program for rendering bounding box.
 205   Standard_Boolean BindBoundBoxProgram()
 206   {
 207     if (myBoundBoxProgram.IsNull())
 208     {
 209       prepareStdProgramBoundBox();
 210     }
 211     return bindProgramWithState (myBoundBoxProgram, Graphic3d_TOSM_UNLIT);
 212   }
 213
 214   //! Returns bounding box vertex buffer.
 215   const Handle(OpenGl_VertexBuffer)& BoundBoxVertBuffer() const { return myBoundBoxVertBuffer; }
 216
 217   //! Bind program for IBL maps generation in PBR pipeline.
 218   Standard_Boolean BindPBREnvBakingProgram (Standard_Integer theIndex)
 219   {
 220     if (myPBREnvBakingProgram[theIndex].IsNull())
 221     {
 222       preparePBREnvBakingProgram (theIndex);
 223     }
 224     return myContext->BindProgram (myPBREnvBakingProgram[theIndex]);
 225   }
 226
 227   //! Generates shader program to render environment cubemap as background.
 228   Standard_EXPORT const Handle(Graphic3d_ShaderProgram)& GetBgCubeMapProgram ();
 229
 230   //! Resets PBR shading models to corresponding non-PBR ones if PBR is not allowed.
 231   static Graphic3d_TypeOfShadingModel PBRShadingModelFallback (Graphic3d_TypeOfShadingModel theShadingModel,
 232                                                                Standard_Boolean             theIsPbrAllowed = Standard_False)
 233   {
 234     if (theIsPbrAllowed)
 235     {
 236       return theShadingModel;
 237     }
 238
 239     switch (theShadingModel)
 240     {
 241       case Graphic3d_TOSM_PBR:       return Graphic3d_TOSM_FRAGMENT;
 242       case Graphic3d_TOSM_PBR_FACET: return Graphic3d_TOSM_FACET;
 243       default: return theShadingModel;
 244     }
 245   }
 246
 247 public:
 248
 249   //! Returns current state of OCCT light sources.
 250   const OpenGl_LightSourceState& LightSourceState() const { return myLightSourceState; }
 251
 252   //! Updates state of OCCT light sources.
 253   Standard_EXPORT void UpdateLightSourceStateTo (const Handle(Graphic3d_LightSet)& theLights,
 254                                                  Standard_Integer theSpecIBLMapLevels,
 255                                                  const Handle(OpenGl_ShadowMapArray)& theShadowMaps);
 256
 257   //! Updates state of OCCT light sources to dynamically enable/disable shadowmap.
 258   //! @param theToCast [in] flag to enable/disable shadowmap
 259   //! @return previous flag state
 260   bool SetCastShadows (const bool theToCast)
 261   {
 262     if (myLightSourceState.ShadowMaps().IsNull()
 263      || myLightSourceState.ToCastShadows() == theToCast)
 264         {
 265       return myLightSourceState.ToCastShadows();
 266     }
 267
 268     myLightSourceState.SetCastShadows (theToCast);
 269     switchLightPrograms();
 270     return !theToCast;
 271   }
 272
 273   //! Invalidate state of OCCT light sources.
 274   Standard_EXPORT void UpdateLightSourceState();
 275
 276   //! Pushes current state of OCCT light sources to specified program (only on state change).
 277   //! Note that light sources definition depends also on WorldViewState.
 278   void PushLightSourceState (const Handle(OpenGl_ShaderProgram)& theProgram) const
 279   {
 280     if (myLightSourceState.Index() != theProgram->ActiveState (OpenGl_LIGHT_SOURCES_STATE)
 281      || myWorldViewState.Index()   != theProgram->ActiveState (OpenGl_WORLD_VIEW_STATE))
 282     {
 283       pushLightSourceState (theProgram);
 284     }
 285   }
 286
 287   //! Pushes current state of OCCT light sources to specified program.
 288   Standard_EXPORT void pushLightSourceState (const Handle(OpenGl_ShaderProgram)& theProgram) const;
 289
 290 public:
 291
 292   //! Returns current state of OCCT projection transform.
 293   const OpenGl_ProjectionState& ProjectionState() const { return myProjectionState; }
 294
 295   //! Updates state of OCCT projection transform.
 296   Standard_EXPORT void UpdateProjectionStateTo (const OpenGl_Mat4& theProjectionMatrix);
 297
 298   //! Pushes current state of OCCT projection transform to specified program (only on state change).
 299   void PushProjectionState (const Handle(OpenGl_ShaderProgram)& theProgram) const
 300   {
 301     if (myProjectionState.Index() != theProgram->ActiveState (OpenGl_PROJECTION_STATE))
 302     {
 303       pushProjectionState (theProgram);
 304     }
 305   }
 306
 307   //! Pushes current state of OCCT projection transform to specified program.
 308   Standard_EXPORT void pushProjectionState (const Handle(OpenGl_ShaderProgram)& theProgram) const;
 309
 310 public:
 311
 312   //! Returns current state of OCCT model-world transform.
 313   const OpenGl_ModelWorldState& ModelWorldState() const { return myModelWorldState; }
 314
 315   //! Updates state of OCCT model-world transform.
 316   Standard_EXPORT void UpdateModelWorldStateTo (const OpenGl_Mat4& theModelWorldMatrix);
 317
 318   //! Pushes current state of OCCT model-world transform to specified program (only on state change).
 319   void PushModelWorldState (const Handle(OpenGl_ShaderProgram)& theProgram) const
 320   {
 321     if (myModelWorldState.Index() != theProgram->ActiveState (OpenGl_MODEL_WORLD_STATE))
 322     {
 323       pushModelWorldState (theProgram);
 324     }
 325   }
 326
 327   //! Pushes current state of OCCT model-world transform to specified program.
 328   Standard_EXPORT void pushModelWorldState (const Handle(OpenGl_ShaderProgram)& theProgram) const;
 329
 330 public:
 331
 332   //! Returns current state of OCCT world-view transform.
 333   const OpenGl_WorldViewState& WorldViewState() const { return myWorldViewState; }
 334
 335   //! Updates state of OCCT world-view transform.
 336   Standard_EXPORT void UpdateWorldViewStateTo (const OpenGl_Mat4& theWorldViewMatrix);
 337
 338   //! Pushes current state of OCCT world-view transform to specified program (only on state change).
 339   void PushWorldViewState (const Handle(OpenGl_ShaderProgram)& theProgram) const
 340   {
 341     if (myWorldViewState.Index() != theProgram->ActiveState (OpenGl_WORLD_VIEW_STATE))
 342     {
 343       pushWorldViewState (theProgram);
 344     }
 345   }
 346
 347   //! Pushes current state of OCCT world-view transform to specified program.
 348   Standard_EXPORT void pushWorldViewState (const Handle(OpenGl_ShaderProgram)& theProgram) const;
 349
 350 public:
 351
 352   //! Updates state of OCCT clipping planes.
 353   Standard_EXPORT void UpdateClippingState();
 354
 355   //! Reverts state of OCCT clipping planes.
 356   Standard_EXPORT void RevertClippingState();
 357
 358   //! Pushes current state of OCCT clipping planes to specified program (only on state change).
 359   void PushClippingState (const Handle(OpenGl_ShaderProgram)& theProgram) const
 360   {
 361     if (myClippingState.Index() != theProgram->ActiveState (OpenGl_CLIP_PLANES_STATE))
 362     {
 363       pushClippingState (theProgram);
 364     }
 365   }
 366
 367   //! Pushes current state of OCCT clipping planes to specified program.
 368   Standard_EXPORT void pushClippingState (const Handle(OpenGl_ShaderProgram)& theProgram) const;
 369
 370 public:
 371
 372   //! Returns current state of material.
 373   const OpenGl_MaterialState& MaterialState() const { return myMaterialState; }
 374
 375   //! Updates state of material.
 376   void UpdateMaterialStateTo (const OpenGl_Material& theFrontMat,
 377                               const OpenGl_Material& theBackMat,
 378                               const float theAlphaCutoff,
 379                               const bool theToDistinguish,
 380                               const bool theToMapTexture)
 381   {
 382     myMaterialState.Set (theFrontMat, theBackMat, theAlphaCutoff, theToDistinguish, theToMapTexture);
 383     myMaterialState.Update();
 384   }
 385
 386   //! Updates state of material.
 387   void UpdateMaterialState()
 388   {
 389     myMaterialState.Update();
 390   }
 391
 392   //! Pushes current state of material to specified program (only on state change).
 393   void PushMaterialState (const Handle(OpenGl_ShaderProgram)& theProgram) const
 394   {
 395     if (myMaterialState.Index() != theProgram->ActiveState (OpenGl_MATERIAL_STATE))
 396     {
 397       pushMaterialState (theProgram);
 398     }
 399   }
 400
 401   //! Pushes current state of material to specified program.
 402   Standard_EXPORT void pushMaterialState (const Handle(OpenGl_ShaderProgram)& theProgram) const;
 403
 404 public:
 405
 406   //! Setup interior style line edges variables.
 407   Standard_EXPORT void PushInteriorState (const Handle(OpenGl_ShaderProgram)& theProgram,
 408                                           const Handle(Graphic3d_Aspects)& theAspect) const;
 409
 410 public:
 411
 412   //! Returns state of OIT uniforms.
 413   const OpenGl_OitState& OitState() const { return myOitState; }
 414
 415   //! Reset the state of OIT rendering pass (only on state change).
 416   void ResetOitState()
 417   {
 418     myOitState.Set (Graphic3d_RTM_BLEND_UNORDERED, 0.0f);
 419     myOitState.Update();
 420   }
 421
 422   //! Set the state of OIT rendering pass (only on state change).
 423   //! @param theMode [in] flag indicating whether the special output should be written for OIT algorithm
 424   void SetOitState (Graphic3d_RenderTransparentMethod theMode)
 425   {
 426     myOitState.Set (theMode, 0.0f);
 427     myOitState.Update();
 428   }
 429
 430   //! Set the state of weighed OIT rendering pass (only on state change).
 431   //! @param theDepthFactor [in] the scalar factor of depth influence to the fragment's coverage
 432   void SetWeighedOitState (float theDepthFactor)
 433   {
 434     myOitState.Set (Graphic3d_RTM_BLEND_OIT, theDepthFactor);
 435     myOitState.Update();
 436   }
 437
 438   //! Pushes state of OIT uniforms to the specified program.
 439   void PushOitState (const Handle(OpenGl_ShaderProgram)& theProgram) const
 440   {
 441     if (theProgram->IsValid()
 442      && myOitState.Index() != theProgram->ActiveState (OpenGL_OIT_STATE))
 443     {
 444       pushOitState (theProgram);
 445     }
 446   }
 447
 448   //! Pushes state of OIT uniforms to the specified program.
 449   Standard_EXPORT void pushOitState (const Handle(OpenGl_ShaderProgram)& theProgram) const;
 450
 451 public:
 452
 453   //! Pushes current state of OCCT graphics parameters to specified program.
 454   Standard_EXPORT void PushState (const Handle(OpenGl_ShaderProgram)& theProgram,
 455                                   Graphic3d_TypeOfShadingModel theShadingModel = Graphic3d_TOSM_UNLIT) const;
 456
 457 public:
 458
 459   //! Overwrites context
 460   void SetContext (OpenGl_Context* theCtx)
 461   {
 462     myContext = theCtx;
 463   }
 464
 465   //! Returns true when provided context is the same as used one by shader manager.
 466   bool IsSameContext (OpenGl_Context* theCtx) const
 467   {
 468     return myContext == theCtx;
 469   }
 470
 471   //! Choose Shading Model for filled primitives.
 472   //! Fallbacks to FACET model if there are no normal attributes.
 473   //! Fallbacks to corresponding non-PBR models if PBR is unavailable.
 474   Graphic3d_TypeOfShadingModel ChooseFaceShadingModel (Graphic3d_TypeOfShadingModel theCustomModel,
 475                                                        bool theHasNodalNormals) const
 476   {
 477     if (!myContext->ColorMask())
 478     {
 479       return Graphic3d_TOSM_UNLIT;
 480     }
 481     Graphic3d_TypeOfShadingModel aModel = theCustomModel != Graphic3d_TOSM_DEFAULT ? theCustomModel : myShadingModel;
 482     switch (aModel)
 483     {
 484       case Graphic3d_TOSM_DEFAULT:
 485       case Graphic3d_TOSM_UNLIT:
 486       case Graphic3d_TOSM_FACET:
 487         return aModel;
 488       case Graphic3d_TOSM_VERTEX:
 489       case Graphic3d_TOSM_FRAGMENT:
 490         return theHasNodalNormals ? aModel : Graphic3d_TOSM_FACET;
 491       case Graphic3d_TOSM_PBR:
 492         return PBRShadingModelFallback (theHasNodalNormals ? aModel : Graphic3d_TOSM_PBR_FACET, IsPbrAllowed());
 493       case Graphic3d_TOSM_PBR_FACET:
 494         return PBRShadingModelFallback (aModel, IsPbrAllowed());
 495     }
 496     return Graphic3d_TOSM_UNLIT;
 497   }
 498
 499   //! Choose Shading Model for line primitives.
 500   //! Fallbacks to UNLIT model if there are no normal attributes.
 501   //! Fallbacks to corresponding non-PBR models if PBR is unavailable.
 502   Graphic3d_TypeOfShadingModel ChooseLineShadingModel (Graphic3d_TypeOfShadingModel theCustomModel,
 503                                                        bool theHasNodalNormals) const
 504   {
 505     if (!myContext->ColorMask())
 506     {
 507       return Graphic3d_TOSM_UNLIT;
 508     }
 509     Graphic3d_TypeOfShadingModel aModel = theCustomModel != Graphic3d_TOSM_DEFAULT ? theCustomModel : myShadingModel;
 510     switch (aModel)
 511     {
 512       case Graphic3d_TOSM_DEFAULT:
 513       case Graphic3d_TOSM_UNLIT:
 514       case Graphic3d_TOSM_FACET:
 515         return Graphic3d_TOSM_UNLIT;
 516       case Graphic3d_TOSM_VERTEX:
 517       case Graphic3d_TOSM_FRAGMENT:
 518         return theHasNodalNormals ? aModel : Graphic3d_TOSM_UNLIT;
 519       case Graphic3d_TOSM_PBR:
 520         return PBRShadingModelFallback (theHasNodalNormals ? aModel : Graphic3d_TOSM_UNLIT, IsPbrAllowed());
 521       case Graphic3d_TOSM_PBR_FACET:
 522         return Graphic3d_TOSM_UNLIT;
 523     }
 524     return Graphic3d_TOSM_UNLIT;
 525   }
 526
 527   //! Choose Shading Model for Marker primitives.
 528   Graphic3d_TypeOfShadingModel ChooseMarkerShadingModel (Graphic3d_TypeOfShadingModel theCustomModel,
 529                                                          bool theHasNodalNormals) const
 530   {
 531     return ChooseLineShadingModel (theCustomModel, theHasNodalNormals);
 532   }
 533
 534   //! Returns default Shading Model.
 535   Graphic3d_TypeOfShadingModel ShadingModel() const { return myShadingModel; }
 536
 537   //! Sets shading model.
 538   Standard_EXPORT void SetShadingModel (const Graphic3d_TypeOfShadingModel theModel);
 539
 540 protected:
 541
 542   //! Define clipping planes program bits.
 543   Standard_Integer getClipPlaneBits() const
 544   {
 545     const Standard_Integer aNbPlanes = myContext->Clipping().NbClippingOrCappingOn();
 546     if (aNbPlanes <= 0)
 547     {
 548       return 0;
 549     }
 550
 551     Standard_Integer aBits = 0;
 552     if (myContext->Clipping().HasClippingChains())
 553     {
 554       aBits |= Graphic3d_ShaderFlags_ClipChains;
 555     }
 556
 557     if (aNbPlanes == 1)
 558     {
 559       aBits |= Graphic3d_ShaderFlags_ClipPlanes1;
 560     }
 561     else if (aNbPlanes == 2)
 562     {
 563       aBits |= Graphic3d_ShaderFlags_ClipPlanes2;
 564     }
 565     else
 566     {
 567       aBits |= Graphic3d_ShaderFlags_ClipPlanesN;
 568     }
 569     return aBits;
 570   }
 571
 572   //! Define program bits.
 573   Standard_Integer getProgramBits (const Handle(OpenGl_TextureSet)& theTextures,
 574                                    Graphic3d_AlphaMode theAlphaMode,
 575                                    Aspect_InteriorStyle theInteriorStyle,
 576                                    Standard_Boolean theHasVertColor,
 577                                    Standard_Boolean theEnableEnvMap,
 578                                    Standard_Boolean theEnableMeshEdges) const
 579   {
 580     Standard_Integer aBits = 0;
 581     if (theAlphaMode == Graphic3d_AlphaMode_Mask
 582      || theAlphaMode == Graphic3d_AlphaMode_MaskBlend)
 583     {
 584       aBits |= Graphic3d_ShaderFlags_AlphaTest;
 585     }
 586
 587     aBits |= getClipPlaneBits();
 588     if (theEnableMeshEdges
 589      && myContext->hasGeometryStage != OpenGl_FeatureNotAvailable)
 590     {
 591       aBits |= Graphic3d_ShaderFlags_MeshEdges;
 592       if (theInteriorStyle == Aspect_IS_HOLLOW)
 593       {
 594         aBits |= Graphic3d_ShaderFlags_AlphaTest;
 595       }
 596     }
 597
 598     if (theEnableEnvMap)
 599     {
 600       // Environment map overwrites material texture
 601       aBits |= Graphic3d_ShaderFlags_TextureEnv;
 602     }
 603     else if (!theTextures.IsNull()
 604            && theTextures->HasNonPointSprite())
 605     {
 606       aBits |= Graphic3d_ShaderFlags_TextureRGB;
 607       if ((theTextures->TextureSetBits() & Graphic3d_TextureSetBits_Normal) != 0)
 608       {
 609         aBits |= Graphic3d_ShaderFlags_TextureNormal;
 610       }
 611     }
 612     if (theHasVertColor
 613      && theInteriorStyle != Aspect_IS_HIDDENLINE)
 614     {
 615       aBits |= Graphic3d_ShaderFlags_VertColor;
 616     }
 617
 618     if (myOitState.ActiveMode() == Graphic3d_RTM_BLEND_OIT)
 619     {
 620       aBits |= Graphic3d_ShaderFlags_WriteOit;
 621     }
 622     else if (myOitState.ActiveMode() == Graphic3d_RTM_DEPTH_PEELING_OIT)
 623     {
 624       aBits |= Graphic3d_ShaderFlags_OitDepthPeeling;
 625     }
 626     return aBits;
 627   }
 628
 629   //! Prepare standard GLSL program.
 630   Handle(OpenGl_ShaderProgram)& getStdProgram (Graphic3d_TypeOfShadingModel theShadingModel,
 631                                                Standard_Integer theBits)
 632   {
 633     if (theShadingModel == Graphic3d_TOSM_UNLIT
 634      || (theBits & Graphic3d_ShaderFlags_HasTextures) == Graphic3d_ShaderFlags_TextureEnv)
 635     {
 636       // If environment map is enabled lighting calculations are
 637       // not needed (in accordance with default OCCT behavior)
 638       Handle(OpenGl_ShaderProgram)& aProgram = myUnlitPrograms->ChangeValue (theBits);
 639       if (aProgram.IsNull())
 640       {
 641         prepareStdProgramUnlit (aProgram, theBits, false);
 642       }
 643       return aProgram;
 644     }
 645
 646     Handle(OpenGl_ShaderProgram)& aProgram = myLightPrograms->ChangeValue (theShadingModel, theBits);
 647     if (aProgram.IsNull())
 648     {
 649       prepareStdProgramLight (aProgram, theShadingModel, theBits);
 650     }
 651     return aProgram;
 652   }
 653
 654   //! Prepare standard GLSL program without lighting.
 655   Standard_EXPORT Standard_Boolean prepareStdProgramUnlit (Handle(OpenGl_ShaderProgram)& theProgram,
 656                                                            Standard_Integer theBits,
 657                                                            Standard_Boolean theIsOutline = false);
 658
 659   //! Prepare standard GLSL program with lighting.
 660   Standard_Boolean prepareStdProgramLight (Handle(OpenGl_ShaderProgram)& theProgram,
 661                                            Graphic3d_TypeOfShadingModel theShadingModel,
 662                                            Standard_Integer theBits)
 663   {
 664     switch (theShadingModel)
 665     {
 666       case Graphic3d_TOSM_UNLIT:     return prepareStdProgramUnlit  (theProgram, theBits, false);
 667       case Graphic3d_TOSM_FACET:     return prepareStdProgramPhong  (theProgram, theBits, true);
 668       case Graphic3d_TOSM_VERTEX:    return prepareStdProgramGouraud(theProgram, theBits);
 669       case Graphic3d_TOSM_DEFAULT:
 670       case Graphic3d_TOSM_FRAGMENT:  return prepareStdProgramPhong  (theProgram, theBits, false);
 671       case Graphic3d_TOSM_PBR:       return prepareStdProgramPhong  (theProgram, theBits, false, true);
 672       case Graphic3d_TOSM_PBR_FACET: return prepareStdProgramPhong  (theProgram, theBits, true, true);
 673     }
 674     return false;
 675   }
 676
 677   //! Prepare standard GLSL program with per-vertex lighting.
 678   Standard_EXPORT Standard_Boolean prepareStdProgramGouraud (Handle(OpenGl_ShaderProgram)& theProgram,
 679                                                              const Standard_Integer        theBits);
 680
 681   //! Prepare standard GLSL program with per-pixel lighting.
 682   //! @param theIsFlatNormal when TRUE, the Vertex normals will be ignored and Face normal will be computed instead
 683   //! @param theIsPBR when TRUE, the PBR pipeline will be activated
 684   Standard_EXPORT Standard_Boolean prepareStdProgramPhong (Handle(OpenGl_ShaderProgram)& theProgram,
 685                                                            const Standard_Integer        theBits,
 686                                                            const Standard_Boolean        theIsFlatNormal = false,
 687                                                            const Standard_Boolean        theIsPBR = false);
 688
 689   //! Bind specified program to current context and apply state.
 690   Standard_EXPORT Standard_Boolean bindProgramWithState (const Handle(OpenGl_ShaderProgram)& theProgram,
 691                                                          Graphic3d_TypeOfShadingModel theShadingModel);
 692
 693   //! Set pointer myLightPrograms to active lighting programs set from myMapOfLightPrograms
 694   Standard_EXPORT void switchLightPrograms();
 695
 696   //! Prepare standard GLSL program for bounding box.
 697   Standard_EXPORT Standard_Boolean prepareStdProgramBoundBox();
 698
 699   //! Prepare GLSL source for IBL generation used in PBR pipeline.
 700   Standard_EXPORT Standard_Boolean preparePBREnvBakingProgram (Standard_Integer theIndex);
 701
 702   //! Checks whether one of PBR shading models is set as default model.
 703   Standard_Boolean IsPbrAllowed() const { return myShadingModel == Graphic3d_TOSM_PBR
 704                                               || myShadingModel == Graphic3d_TOSM_PBR_FACET; }
 705
 706 protected:
 707
 708   //! Packed properties of light source
 709   struct OpenGl_ShaderLightParameters
 710   {
 711     OpenGl_Vec4 Color;      //!< RGB color + Intensity (in .w)
 712     OpenGl_Vec4 Position;   //!< XYZ Direction or Position + IsHeadlight (in .w)
 713     OpenGl_Vec4 Direction;  //!< spot light XYZ direction + Range (in .w)
 714     OpenGl_Vec4 Parameters; //!< same as Graphic3d_CLight::PackedParams()
 715
 716     //! Returns packed (serialized) representation of light source properties
 717     const OpenGl_Vec4* Packed() const { return reinterpret_cast<const OpenGl_Vec4*> (this); }
 718     static Standard_Integer NbOfVec4() { return 4; }
 719   };
 720
 721   //! Fake OpenGL program for tracking FFP state in the way consistent to programmable pipeline.
 722   class OpenGl_ShaderProgramFFP : public OpenGl_ShaderProgram
 723   {
 724     DEFINE_STANDARD_RTTI_INLINE(OpenGl_ShaderProgramFFP, OpenGl_ShaderProgram)
 725     friend class OpenGl_ShaderManager;
 726   protected:
 727     OpenGl_ShaderProgramFFP() {}
 728   };
 729
 730 protected:
 731
 732   //! Append clipping plane definition to temporary buffers.
 733   void addClippingPlane (Standard_Integer& thePlaneId,
 734                          const Graphic3d_ClipPlane& thePlane,
 735                          const Graphic3d_Vec4d& theEq,
 736                          const Standard_Integer theChainFwd) const
 737   {
 738     myClipChainArray.SetValue (thePlaneId, theChainFwd);
 739     OpenGl_Vec4& aPlaneEq = myClipPlaneArray.ChangeValue (thePlaneId);
 740     aPlaneEq.x() = float(theEq.x());
 741     aPlaneEq.y() = float(theEq.y());
 742     aPlaneEq.z() = float(theEq.z());
 743     aPlaneEq.w() = float(theEq.w());
 744     if (myHasLocalOrigin)
 745     {
 746       aPlaneEq.w() = float(LocalClippingPlaneW (thePlane));
 747     }
 748     ++thePlaneId;
 749   }
 750
 751 protected:
 752
 753   Handle(OpenGl_ShaderProgramFFP)    myFfpProgram;
 754
 755   Graphic3d_TypeOfShadingModel       myShadingModel;       //!< lighting shading model
 756   OpenGl_ShaderProgramList           myProgramList;        //!< The list of shader programs
 757   Handle(OpenGl_SetOfShaderPrograms) myLightPrograms;      //!< pointer to active lighting programs matrix
 758   Handle(OpenGl_SetOfPrograms)       myUnlitPrograms;      //!< programs matrix without lighting
 759   Handle(OpenGl_SetOfPrograms)       myOutlinePrograms;    //!< programs matrix without lighting for outline presentation
 760   Handle(OpenGl_ShaderProgram)       myFontProgram;        //!< standard program for textured text
 761   NCollection_Array1<Handle(OpenGl_ShaderProgram)>
 762                                      myBlitPrograms[2];    //!< standard program for FBO blit emulation
 763   Handle(OpenGl_ShaderProgram)       myBoundBoxProgram;    //!< standard program for bounding box
 764   Handle(OpenGl_ShaderProgram)       myOitCompositingProgram[2]; //!< standard program for OIT compositing (default and MSAA).
 765   Handle(OpenGl_ShaderProgram)       myOitDepthPeelingBlendProgram[2]; //!< standard program for OIT Depth Peeling blend (default and MSAA)
 766   Handle(OpenGl_ShaderProgram)       myOitDepthPeelingFlushProgram[2]; //!< standard program for OIT Depth Peeling flush (default and MSAA)
 767   OpenGl_MapOfShaderPrograms         myMapOfLightPrograms; //!< map of lighting programs depending on lights configuration
 768
 769   Handle(OpenGl_ShaderProgram)       myPBREnvBakingProgram[3]; //!< programs for IBL maps generation used in PBR pipeline (0 for Diffuse; 1 for Specular; 2 for fallback)
 770   Handle(Graphic3d_ShaderProgram)    myBgCubeMapProgram;   //!< program for background cubemap rendering
 771
 772   Handle(OpenGl_ShaderProgram)       myStereoPrograms[Graphic3d_StereoMode_NB]; //!< standard stereo programs
 773
 774   Handle(OpenGl_VertexBuffer)        myBoundBoxVertBuffer; //!< bounding box vertex buffer
 775
 776   mutable Handle(OpenGl_PBREnvironment) myPBREnvironment;  //!< manager of IBL maps used in PBR pipeline
 777
 778   OpenGl_Context*                    myContext;            //!< OpenGL context
 779
 780 protected:
 781
 782   OpenGl_ProjectionState             myProjectionState;    //!< State of OCCT projection  transformation
 783   OpenGl_ModelWorldState             myModelWorldState;    //!< State of OCCT model-world transformation
 784   OpenGl_WorldViewState              myWorldViewState;     //!< State of OCCT world-view  transformation
 785   OpenGl_ClippingState               myClippingState;      //!< State of OCCT clipping planes
 786   OpenGl_LightSourceState            myLightSourceState;   //!< State of OCCT light sources
 787   OpenGl_MaterialState               myMaterialState;      //!< State of Front and Back materials
 788   OpenGl_OitState                    myOitState;           //!< State of OIT uniforms
 789
 790   gp_XYZ                             myLocalOrigin;        //!< local camera transformation
 791   Standard_Boolean                   myHasLocalOrigin;     //!< flag indicating that local camera transformation has been set
 792
 793   mutable NCollection_Array1<Standard_Integer>             myLightTypeArray;
 794   mutable NCollection_Array1<OpenGl_ShaderLightParameters> myLightParamsArray;
 795   mutable NCollection_Array1<Graphic3d_Mat4>               myShadowMatArray;
 796   mutable NCollection_Array1<OpenGl_Vec4>                  myClipPlaneArray;
 797   mutable NCollection_Array1<OpenGl_Vec4d>                 myClipPlaneArrayFfp;
 798   mutable NCollection_Array1<Standard_Integer>             myClipChainArray;
 799
 800 };
 801
 802 #endif // _OpenGl_ShaderManager_HeaderFile