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