src/OpenGl/OpenGl_Workspace.hxx

   1 // Created on: 2011-09-20
   2 // Created by: Sergey ZERCHANINOV
   3 // Copyright (c) 2011-2013 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_Workspace_Header
  17 #define _OpenGl_Workspace_Header
  18
  19 #include <Graphic3d_BufferType.hxx>
  20
  21 #include <InterfaceGraphic_Graphic3d.hxx>
  22
  23 #include <OpenGl_AspectFace.hxx>
  24 #include <OpenGl_CappingAlgo.hxx>
  25 #include <OpenGl_FrameBuffer.hxx>
  26 #include <OpenGl_LineAttributes.hxx>
  27 #include <OpenGl_Matrix.hxx>
  28 #include <OpenGl_NamedStatus.hxx>
  29 #include <OpenGl_PrinterContext.hxx>
  30 #include <OpenGl_RenderFilter.hxx>
  31 #include <OpenGl_ShaderObject.hxx>
  32 #include <OpenGl_ShaderProgram.hxx>
  33 #include <OpenGl_TextParam.hxx>
  34 #include <OpenGl_TextureBufferArb.hxx>
  35 #include <OpenGl_Vec.hxx>
  36 #include <OpenGl_Window.hxx>
  37
  38 class OpenGl_View;
  39 class Image_PixMap;
  40
  41 //! OpenGL material definition
  42 struct OpenGl_Material
  43 {
  44
  45   OpenGl_Vec4 Ambient;  //!< ambient reflection coefficient
  46   OpenGl_Vec4 Diffuse;  //!< diffuse reflection coefficient
  47   OpenGl_Vec4 Specular; //!< glossy  reflection coefficient
  48   OpenGl_Vec4 Emission; //!< material emission
  49   OpenGl_Vec4 Params;   //!< extra packed parameters
  50
  51   Standard_ShortReal  Shine()              const { return Params.x(); }
  52   Standard_ShortReal& ChangeShine()              { return Params.x(); }
  53
  54   Standard_ShortReal  Transparency()       const { return Params.y(); }
  55   Standard_ShortReal& ChangeTransparency()       { return Params.y(); }
  56
  57   //! Set material color.
  58   void SetColor (const OpenGl_Vec4& theColor)
  59   {
  60     // apply the same formula as in Graphic3d_MaterialAspect::SetColor()
  61     Ambient.xyz() = theColor.rgb() * 0.25f;
  62     Diffuse.xyz() = theColor.rgb();
  63   }
  64
  65   //! Initialize material
  66   void Init (const OPENGL_SURF_PROP& theProps);
  67
  68   //! Returns packed (serialized) representation of material properties
  69   const OpenGl_Vec4* Packed() const { return reinterpret_cast<const OpenGl_Vec4*> (this); }
  70   static Standard_Integer NbOfVec4() { return 5; }
  71
  72 };
  73
  74 class OpenGl_RaytraceFilter;
  75 DEFINE_STANDARD_HANDLE (OpenGl_RaytraceFilter, OpenGl_RenderFilter)
  76
  77 //! Graphical ray-tracing filter.
  78 //! Filters out all raytracable structures.
  79 class OpenGl_RaytraceFilter : public OpenGl_RenderFilter
  80 {
  81 public:
  82
  83   //! Default constructor.
  84   OpenGl_RaytraceFilter() {}
  85
  86   //! Returns the previously set filter.
  87   const Handle(OpenGl_RenderFilter)& PrevRenderFilter()
  88   {
  89     return myPrevRenderFilter;
  90   }
  91
  92   //! Remembers the previously set filter.
  93   void SetPrevRenderFilter (const Handle(OpenGl_RenderFilter)& theFilter)
  94   {
  95     myPrevRenderFilter = theFilter;
  96   }
  97
  98   //! Checks whether the element can be rendered or not.
  99   //! @param theElement [in] the element to check.
 100   //! @return True if element can be rendered.
 101   virtual Standard_Boolean CanRender (const OpenGl_Element* theElement) Standard_OVERRIDE;
 102
 103 private:
 104
 105   Handle(OpenGl_RenderFilter) myPrevRenderFilter;
 106
 107 public:
 108
 109   DEFINE_STANDARD_RTTIEXT(OpenGl_RaytraceFilter,OpenGl_RenderFilter)
 110 };
 111
 112 class OpenGl_Workspace;
 113 DEFINE_STANDARD_HANDLE(OpenGl_Workspace,Standard_Transient)
 114
 115 //! Rendering workspace.
 116 //! Provides methods to render primitives and maintain GL state.
 117 class OpenGl_Workspace : public Standard_Transient
 118 {
 119 public:
 120
 121   //! Constructor of rendering workspace.
 122   Standard_EXPORT OpenGl_Workspace (OpenGl_View* theView, const Handle(OpenGl_Window)& theWindow);
 123
 124   //! Destructor
 125   Standard_EXPORT virtual ~OpenGl_Workspace();
 126
 127   //! Activate rendering context.
 128   Standard_EXPORT Standard_Boolean Activate();
 129
 130   OpenGl_View* View() const { return myView; }
 131
 132   const Handle(OpenGl_Context)& GetGlContext() { return myGlContext; }
 133
 134   Standard_EXPORT Handle(OpenGl_FrameBuffer) FBOCreate (const Standard_Integer theWidth, const Standard_Integer theHeight);
 135
 136   Standard_EXPORT void FBORelease (Handle(OpenGl_FrameBuffer)& theFbo);
 137
 138   Standard_Boolean BufferDump (const Handle(OpenGl_FrameBuffer)& theFbo,
 139                                Image_PixMap&                     theImage,
 140                                const Graphic3d_BufferType&       theBufferType);
 141
 142   Standard_EXPORT Standard_Integer Width()  const;
 143
 144   Standard_EXPORT Standard_Integer Height() const;
 145
 146   //! Setup Z-buffer usage flag (without affecting GL state!).
 147   //! Returns previously set flag.
 148   Standard_Boolean SetUseZBuffer (const Standard_Boolean theToUse)
 149   {
 150     const Standard_Boolean wasUsed = myUseZBuffer;
 151     myUseZBuffer = theToUse;
 152     return wasUsed;
 153   }
 154
 155   Handle(OpenGl_PrinterContext)& PrinterContext() { return myPrintContext; }
 156
 157   //! @return true if usage of Z buffer is enabled.
 158   Standard_Boolean& UseZBuffer() { return myUseZBuffer; }
 159
 160   //! @return true if depth writing is enabled.
 161   Standard_Boolean& UseDepthWrite() { return myUseDepthWrite; }
 162
 163   //! @return true if usage of GL light is enabled.
 164   Standard_EXPORT Standard_Boolean  UseGLLight() const;
 165
 166   //! @return true if antialiasing is enabled.
 167   Standard_EXPORT Standard_Integer AntiAliasingMode() const;
 168
 169   //! @return true if clipping algorithm enabled
 170   Standard_EXPORT Standard_Boolean IsCullingEnabled() const;
 171
 172   Standard_Integer NamedStatus;
 173
 174   //// RELATED TO STATUS ////
 175
 176   const TEL_COLOUR* HighlightColor;
 177
 178   //! Return true if following structures should apply highlight color.
 179   bool ToHighlight() const { return myToHighlight; }
 180
 181   //! Set highlight.
 182   void SetHighlight (bool theToHighlight) { myToHighlight = theToHighlight; }
 183
 184   //! Return line color taking into account highlight flag.
 185   const TEL_COLOUR& LineColor() const
 186   {
 187     return myToHighlight
 188          ? *HighlightColor
 189          : myAspectLineSet->Color();
 190   }
 191
 192   //! Return edge color taking into account highlight flag.
 193   const TEL_COLOUR& EdgeColor() const
 194   {
 195     return myToHighlight
 196          ? *HighlightColor
 197          : myAspectFaceSet->AspectEdge()->Color();
 198   }
 199
 200   //! Return marker color taking into account highlight flag.
 201   const TEL_COLOUR& MarkerColor() const
 202   {
 203     return myToHighlight
 204          ? *HighlightColor
 205          : myAspectMarkerSet->Color();
 206   }
 207
 208   //! Return Interior color taking into account highlight flag.
 209   const TEL_COLOUR& InteriorColor() const
 210   {
 211     return myToHighlight
 212          ? *HighlightColor
 213          : myAspectFaceSet->IntFront().matcol;
 214   }
 215
 216   //! Return text color taking into account highlight flag.
 217   const TEL_COLOUR& TextColor() const
 218   {
 219     return myToHighlight
 220          ? *HighlightColor
 221          : myAspectTextSet->Color();
 222   }
 223
 224   //! Return text Subtitle color taking into account highlight flag.
 225   const TEL_COLOUR& TextSubtitleColor() const
 226   {
 227     return myToHighlight
 228          ? *HighlightColor
 229          : myAspectTextSet->SubtitleColor();
 230   }
 231
 232   //! Currently set line aspect (can differ from applied).
 233   const OpenGl_AspectLine*   AspectLine()   const { return myAspectLineSet; }
 234
 235   //! Currently set face aspect (can differ from applied).
 236   const OpenGl_AspectFace*   AspectFace()   const { return myAspectFaceSet; }
 237
 238   //! Currently set marker aspect (can differ from applied).
 239   const OpenGl_AspectMarker* AspectMarker() const { return myAspectMarkerSet; }
 240
 241   //! Currently set text aspect (can differ from applied).
 242   const OpenGl_AspectText*   AspectText()   const { return myAspectTextSet; }
 243
 244   //! Assign new line aspect (will be applied within ApplyAspectLine()).
 245   Standard_EXPORT const OpenGl_AspectLine*   SetAspectLine   (const OpenGl_AspectLine*   theAspect);
 246
 247   //! Assign new face aspect (will be applied within ApplyAspectFace()).
 248   Standard_EXPORT const OpenGl_AspectFace*   SetAspectFace   (const OpenGl_AspectFace*   theAspect);
 249
 250   //! Assign new marker aspect (will be applied within ApplyAspectMarker()).
 251   Standard_EXPORT const OpenGl_AspectMarker* SetAspectMarker (const OpenGl_AspectMarker* theAspect);
 252
 253   //! Assign new text aspect (will be applied within ApplyAspectText()).
 254   Standard_EXPORT const OpenGl_AspectText*   SetAspectText   (const OpenGl_AspectText*   theAspect);
 255
 256   //! Apply line aspect.
 257   //! @return aspect set by SetAspectLine()
 258   const OpenGl_AspectLine* ApplyAspectLine() { return myAspectLineSet; }
 259
 260   //! Apply face aspect.
 261   //! @return aspect set by SetAspectFace()
 262   Standard_EXPORT const OpenGl_AspectFace*   ApplyAspectFace();
 263
 264   //! Apply marker aspect.
 265   //! @return aspect set by SetAspectMarker()
 266   Standard_EXPORT const OpenGl_AspectMarker* ApplyAspectMarker();
 267
 268   //! Apply text aspect.
 269   //! @return aspect set by SetAspectText()
 270   const OpenGl_AspectText* ApplyAspectText() { return myAspectTextSet; }
 271
 272   //! Clear the applied aspect state to default values.
 273   void ResetAppliedAspect();
 274
 275   Standard_EXPORT Handle(OpenGl_Texture) DisableTexture();
 276   Standard_EXPORT Handle(OpenGl_Texture) EnableTexture (const Handle(OpenGl_Texture)&          theTexture,
 277                                                         const Handle(Graphic3d_TextureParams)& theParams = NULL);
 278   const Handle(OpenGl_Texture)& ActiveTexture() const { return myTextureBound; }
 279
 280   //! Set filter for restricting rendering of particular elements.
 281   //! Filter can be applied for rendering passes used by recursive
 282   //! rendering algorithms for rendering elements of groups.
 283   //! @param theFilter [in] the filter instance.
 284   inline void SetRenderFilter (const Handle(OpenGl_RenderFilter)& theFilter)
 285   {
 286     myRenderFilter = theFilter;
 287   }
 288
 289   //! Get rendering filter.
 290   //! @return filter instance.
 291   inline const Handle(OpenGl_RenderFilter)& GetRenderFilter() const
 292   {
 293     return myRenderFilter;
 294   }
 295
 296   //! @return applied view matrix.
 297   inline const OpenGl_Matrix* ViewMatrix() const { return ViewMatrix_applied; }
 298
 299   //! @return applied model structure matrix.
 300   inline const OpenGl_Matrix* ModelMatrix() const { return StructureMatrix_applied; }
 301
 302   //! Sets and applies current polygon offset.
 303   void SetPolygonOffset (int theMode, Standard_ShortReal theFactor, Standard_ShortReal theUnits);
 304
 305   //! Returns currently applied polygon offset params.
 306   const TEL_POFFSET_PARAM& AppliedPolygonOffset() { return PolygonOffset_applied; }
 307
 308   //! Returns capping algorithm rendering filter.
 309   const Handle(OpenGl_CappingAlgoFilter)& DefaultCappingAlgoFilter() const
 310   {
 311     return myDefaultCappingAlgoFilter;
 312   }
 313
 314   //! Returns face aspect for none culling mode.
 315   const OpenGl_AspectFace& NoneCulling() const
 316   {
 317     return myNoneCulling;
 318   }
 319
 320   //! Returns face aspect for front face culling mode.
 321   const OpenGl_AspectFace& FrontCulling() const
 322   {
 323     return myFrontCulling;
 324   }
 325
 326   //! Sets a new environment texture.
 327   void SetEnvironmentTexture (const Handle(OpenGl_Texture)& theTexture)
 328   {
 329     myEnvironmentTexture = theTexture;
 330   }
 331
 332   //! Returns environment texture.
 333   const Handle(OpenGl_Texture)& EnvironmentTexture() const
 334   {
 335     return myEnvironmentTexture;
 336   }
 337
 338 protected:
 339
 340   void updateMaterial (const int theFlag);
 341
 342   void setTextureParams (Handle(OpenGl_Texture)&                theTexture,
 343                          const Handle(Graphic3d_TextureParams)& theParams);
 344
 345 protected: //! @name protected fields
 346
 347   OpenGl_View*                     myView;
 348   Handle(OpenGl_Window)            myWindow;
 349   Handle(OpenGl_Context)           myGlContext;
 350   Handle(OpenGl_PrinterContext)    myPrintContext;
 351   Handle(OpenGl_LineAttributes)    myLineAttribs;
 352   Standard_Integer                 myAntiAliasingMode;
 353   Standard_Boolean                 myUseZBuffer;
 354   Standard_Boolean                 myUseDepthWrite;
 355   Standard_Boolean                 myUseGLLight;
 356   Handle(OpenGl_CappingAlgoFilter) myDefaultCappingAlgoFilter;
 357   OpenGl_AspectFace                myNoneCulling;
 358   OpenGl_AspectFace                myFrontCulling;
 359
 360 protected: //! @name fields related to status
 361
 362   Handle(OpenGl_RenderFilter) myRenderFilter;
 363   Handle(OpenGl_Texture) myTextureBound;    //!< currently bound texture (managed by OpenGl_AspectFace and OpenGl_View environment texture)
 364   const OpenGl_AspectLine*   myAspectLineSet;
 365   const OpenGl_AspectFace*   myAspectFaceSet;
 366   const OpenGl_AspectFace*   myAspectFaceApplied;
 367   const OpenGl_AspectMarker* myAspectMarkerSet;
 368   const OpenGl_AspectMarker* myAspectMarkerApplied;
 369   const OpenGl_AspectText*   myAspectTextSet;
 370   bool                       myAspectFaceAppliedWithHL;
 371
 372   const OpenGl_Matrix* ViewMatrix_applied;
 373   const OpenGl_Matrix* StructureMatrix_applied;
 374
 375   OpenGl_Material myMatFront;    //!< current front material state (cached to reduce GL context updates)
 376   OpenGl_Material myMatBack;     //!< current back  material state
 377   OpenGl_Material myMatTmp;      //!< temporary variable
 378   TelCullMode     myCullingMode; //!< back face culling mode, applied from face aspect
 379   bool            myToHighlight; //!< flag indicating highlighting mode
 380
 381   OpenGl_Matrix myModelViewMatrix; //!< Model matrix with applied structure transformations
 382
 383   TEL_POFFSET_PARAM PolygonOffset_applied; //!< Currently applied polygon offset.
 384
 385   OpenGl_AspectFace myAspectFaceHl; //!< Hiddenline aspect
 386
 387   Handle(OpenGl_Texture) myEnvironmentTexture;
 388
 389 public: //! @name type definition
 390
 391   DEFINE_STANDARD_RTTIEXT(OpenGl_Workspace,Standard_Transient)
 392   DEFINE_STANDARD_ALLOC
 393
 394 };
 395
 396 #endif // _OpenGl_Workspace_Header