src/OpenGl/OpenGl_ShaderStates.hxx

   1 // Created on: 2013-10-02
   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_ShaderStates_HeaderFile
  17 #define OpenGl_ShaderStates_HeaderFile
  18
  19 #include <Graphic3d_RenderTransparentMethod.hxx>
  20 #include <Graphic3d_LightSet.hxx>
  21 #include <OpenGl_Element.hxx>
  22 #include <OpenGl_Vec.hxx>
  23
  24 class OpenGl_ShadowMapArray;
  25
  26 //! Defines interface for OpenGL state.
  27 class OpenGl_StateInterface
  28 {
  29 public:
  30
  31   //! Creates new state.
  32   Standard_EXPORT OpenGl_StateInterface();
  33
  34   //! Returns current state index.
  35   Standard_Size Index() const { return myIndex; }
  36
  37   //! Increment current state.
  38   void Update() { ++myIndex; }
  39
  40 protected:
  41
  42   Standard_Size myIndex; //!< current state index
  43
  44 };
  45
  46 //! Defines state of OCCT projection transformation.
  47 class OpenGl_ProjectionState : public OpenGl_StateInterface
  48 {
  49 public:
  50
  51   //! Creates uninitialized projection state.
  52   Standard_EXPORT OpenGl_ProjectionState();
  53
  54   //! Sets new projection matrix.
  55   Standard_EXPORT void Set (const OpenGl_Mat4& theProjectionMatrix);
  56
  57   //! Returns current projection matrix.
  58   const OpenGl_Mat4& ProjectionMatrix() const { return myProjectionMatrix; }
  59
  60   //! Returns inverse of current projection matrix.
  61   Standard_EXPORT const OpenGl_Mat4& ProjectionMatrixInverse() const;
  62
  63 private:
  64
  65   OpenGl_Mat4         myProjectionMatrix;        //!< OCCT projection matrix
  66   mutable OpenGl_Mat4 myProjectionMatrixInverse; //!< Inverse of OCCT projection matrix
  67   mutable bool        myInverseNeedUpdate;       //!< Is inversed matrix outdated?
  68
  69 };
  70
  71 //! Defines state of OCCT model-world transformation.
  72 class OpenGl_ModelWorldState : public OpenGl_StateInterface
  73 {
  74 public:
  75
  76   //! Creates uninitialized model-world state.
  77   Standard_EXPORT OpenGl_ModelWorldState();
  78
  79   //! Sets new model-world matrix.
  80   Standard_EXPORT void Set (const OpenGl_Mat4& theModelWorldMatrix);
  81
  82   //! Returns current model-world matrix.
  83   const OpenGl_Mat4& ModelWorldMatrix() const { return myModelWorldMatrix; }
  84
  85   //! Returns inverse of current model-world matrix.
  86   Standard_EXPORT const OpenGl_Mat4& ModelWorldMatrixInverse() const;
  87
  88 private:
  89
  90   OpenGl_Mat4         myModelWorldMatrix;        //!< OCCT model-world matrix
  91   mutable OpenGl_Mat4 myModelWorldMatrixInverse; //!< Inverse of OCCT model-world matrix
  92   mutable bool        myInverseNeedUpdate;       //!< Is inversed matrix outdated?
  93
  94 };
  95
  96 //! Defines state of OCCT world-view transformation.
  97 class OpenGl_WorldViewState : public OpenGl_StateInterface
  98 {
  99 public:
 100
 101   //! Creates uninitialized world-view state.
 102   Standard_EXPORT OpenGl_WorldViewState();
 103
 104   //! Sets new world-view matrix.
 105   Standard_EXPORT void Set (const OpenGl_Mat4& theWorldViewMatrix);
 106
 107   //! Returns current world-view matrix.
 108   const OpenGl_Mat4& WorldViewMatrix() const { return myWorldViewMatrix; }
 109
 110   //! Returns inverse of current world-view matrix.
 111   Standard_EXPORT const OpenGl_Mat4& WorldViewMatrixInverse() const;
 112
 113 private:
 114
 115   OpenGl_Mat4         myWorldViewMatrix;        //!< OCCT world-view matrix
 116   mutable OpenGl_Mat4 myWorldViewMatrixInverse; //!< Inverse of OCCT world-view matrix
 117   mutable bool        myInverseNeedUpdate;      //!< Is inversed matrix outdated?
 118
 119 };
 120
 121 //! Defines state of OCCT light sources.
 122 class OpenGl_LightSourceState : public OpenGl_StateInterface
 123 {
 124 public:
 125
 126   //! Creates uninitialized state of light sources.
 127   OpenGl_LightSourceState() : mySpecIBLMapLevels (0), myToCastShadows (Standard_True) {}
 128
 129   //! Sets new light sources.
 130   void Set (const Handle(Graphic3d_LightSet)& theLightSources) { myLightSources = theLightSources; }
 131
 132   //! Returns current list of light sources.
 133   const Handle(Graphic3d_LightSet)& LightSources() const { return myLightSources; }
 134
 135   //! Returns number of mipmap levels used in specular IBL map.
 136   //! 0 by default or in case of using non-PBR shading model.
 137   Standard_Integer SpecIBLMapLevels() const { return mySpecIBLMapLevels; }
 138
 139   //! Sets number of mipmap levels used in specular IBL map.
 140   void SetSpecIBLMapLevels(Standard_Integer theSpecIBLMapLevels) { mySpecIBLMapLevels = theSpecIBLMapLevels; }
 141
 142   //! Returns TRUE if shadowmap is set.
 143   bool HasShadowMaps() const { return myToCastShadows && !myShadowMaps.IsNull(); }
 144
 145   //! Returns shadowmap.
 146   const Handle(OpenGl_ShadowMapArray)& ShadowMaps() const { return myShadowMaps; }
 147
 148   //! Sets shadowmap.
 149   void SetShadowMaps (const Handle(OpenGl_ShadowMapArray)& theMap) { myShadowMaps = theMap; }
 150
 151   //! Returns TRUE if shadowmap should be enabled when available; TRUE by default.
 152   bool ToCastShadows() const { return myToCastShadows; }
 153
 154   //! Set if shadowmap should be enabled when available.
 155   void SetCastShadows (bool theToCast) { myToCastShadows = theToCast; }
 156
 157 private:
 158
 159   Handle(Graphic3d_LightSet) myLightSources;     //!< List of OCCT light sources
 160   Standard_Integer           mySpecIBLMapLevels; //!< Number of mipmap levels used in specular IBL map (0 by default or in case of using non-PBR shading model)
 161   Handle(OpenGl_ShadowMapArray) myShadowMaps;    //!< active shadowmap
 162   Standard_Boolean           myToCastShadows;    //!< enable/disable shadowmap
 163
 164 };
 165
 166 //! Defines generic state of OCCT clipping state.
 167 class OpenGl_ClippingState
 168 {
 169 public:
 170
 171   //! Creates new clipping state.
 172   Standard_EXPORT OpenGl_ClippingState();
 173
 174   //! Returns current state index.
 175   Standard_Size Index() const { return myIndex; }
 176
 177   //! Updates current state.
 178   Standard_EXPORT void Update();
 179
 180   //! Reverts current state.
 181   Standard_EXPORT void Revert();
 182
 183 protected:
 184
 185   Standard_Size                   myIndex;      //!< Current state index
 186   Standard_Size                   myNextIndex;  //!< Next    state index
 187   NCollection_List<Standard_Size> myStateStack; //!< Stack of previous states
 188
 189 };
 190
 191 //! Defines generic state of order-independent transparency rendering properties.
 192 class OpenGl_OitState : public OpenGl_StateInterface
 193 {
 194 public:
 195
 196   //! Creates new uniform state.
 197   OpenGl_OitState() : myOitMode (Graphic3d_RTM_BLEND_UNORDERED), myDepthFactor (0.5f) {}
 198
 199   //! Sets the uniform values.
 200   //! @param theToEnableWrite [in] flag indicating whether color and coverage
 201   //!  values for OIT processing should be written by shader program.
 202   //! @param theDepthFactor [in] scalar factor [0-1] defining influence of depth
 203   //!  component of a fragment to its final coverage coefficient.
 204   void Set (Graphic3d_RenderTransparentMethod theMode,
 205             const float theDepthFactor)
 206   {
 207     myOitMode = theMode;
 208     myDepthFactor = static_cast<float> (Max (0.f, Min (1.f, theDepthFactor)));
 209   }
 210
 211   //! Returns flag indicating whether writing of output for OIT processing
 212   //! should be enabled/disabled.
 213   Graphic3d_RenderTransparentMethod ActiveMode() const { return myOitMode; }
 214
 215   //! Returns factor defining influence of depth component of a fragment
 216   //! to its final coverage coefficient.
 217   float DepthFactor() const { return myDepthFactor; }
 218
 219 private:
 220
 221   Graphic3d_RenderTransparentMethod myOitMode;     //!< active OIT method for the main GLSL program
 222   float                             myDepthFactor; //!< factor of depth influence to coverage
 223 };
 224
 225 #endif // _OpenGl_State_HeaderFile