src/OpenGl/OpenGl_LayerList.hxx

   1 // Created on: 2012-02-02
   2 // Created by: Anton POLETAEV
   3 // Copyright (c) 2012-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_LayerList_Header
  17 #define _OpenGl_LayerList_Header
  18
  19 #include <OpenGl_Layer.hxx>
  20 #include <OpenGl_LayerFilter.hxx>
  21
  22 #include <NCollection_Array1.hxx>
  23 #include <NCollection_Handle.hxx>
  24 #include <NCollection_Sequence.hxx>
  25 #include <NCollection_DataMap.hxx>
  26
  27 class OpenGl_Structure;
  28
  29 typedef NCollection_Sequence<Handle(OpenGl_Layer)> OpenGl_SequenceOfLayers;
  30 typedef NCollection_DataMap<int, int> OpenGl_LayerSeqIds;
  31
  32 //! Class defining the list of layers.
  33 class OpenGl_LayerList
  34 {
  35 public:
  36
  37   //! Constructor
  38   OpenGl_LayerList (const Standard_Integer theNbPriorities);
  39
  40   //! Destructor
  41   virtual ~OpenGl_LayerList();
  42
  43   //! Method returns the number of available priorities
  44   Standard_Integer NbPriorities() const { return myNbPriorities; }
  45
  46   //! Number of displayed structures
  47   Standard_Integer NbStructures() const { return myNbStructures; }
  48
  49   //! Return number of structures within immediate layers
  50   Standard_Integer NbImmediateStructures() const { return myImmediateNbStructures; }
  51
  52   //! Insert a new layer with id.
  53   void AddLayer (const Graphic3d_ZLayerId theLayerId);
  54
  55   //! Remove layer by its id.
  56   void RemoveLayer (const Graphic3d_ZLayerId theLayerId);
  57
  58   //! Add structure to list with given priority. The structure will be inserted
  59   //! to specified layer. If the layer isn't found, the structure will be put
  60   //! to default bottom-level layer.
  61   void AddStructure (const OpenGl_Structure*  theStruct,
  62                      const Graphic3d_ZLayerId theLayerId,
  63                      const Standard_Integer   thePriority,
  64                      Standard_Boolean        isForChangePriority = Standard_False);
  65
  66   //! Remove structure from structure list and return its previous priority
  67   void RemoveStructure (const OpenGl_Structure* theStructure);
  68
  69   //! Change structure z layer
  70   //! If the new layer is not presented, the structure will be displayed
  71   //! in default z layer
  72   void ChangeLayer (const OpenGl_Structure*  theStructure,
  73                     const Graphic3d_ZLayerId theOldLayerId,
  74                     const Graphic3d_ZLayerId theNewLayerId);
  75
  76   //! Changes structure priority within its ZLayer
  77   void ChangePriority (const OpenGl_Structure*  theStructure,
  78                        const Graphic3d_ZLayerId theLayerId,
  79                        const Standard_Integer   theNewPriority);
  80
  81   //! Returns reference to the layer with given ID.
  82   OpenGl_Layer& Layer (const Graphic3d_ZLayerId theLayerId);
  83
  84   //! Returns reference to the layer with given ID.
  85   const OpenGl_Layer& Layer (const Graphic3d_ZLayerId theLayerId) const;
  86
  87   //! Assign new settings to the layer.
  88   void SetLayerSettings (const Graphic3d_ZLayerId        theLayerId,
  89                          const Graphic3d_ZLayerSettings& theSettings);
  90
  91   //! Update culling state - should be called before rendering.
  92   void UpdateCulling (const Handle(OpenGl_Workspace)& theWorkspace,
  93                       const Standard_Boolean theToDrawImmediate);
  94
  95   //! Render this element
  96   void Render (const Handle(OpenGl_Workspace)& theWorkspace,
  97                const Standard_Boolean          theToDrawImmediate,
  98                const OpenGl_LayerFilter        theLayersToProcess,
  99                OpenGl_FrameBuffer*             theReadDrawFbo,
 100                OpenGl_FrameBuffer*             theOitAccumFbo) const;
 101
 102   //! Returns the set of OpenGL Z-layers.
 103   const OpenGl_SequenceOfLayers& Layers() const { return myLayers; }
 104
 105   //! Returns the map of Z-layer IDs to indexes.
 106   const OpenGl_LayerSeqIds& LayerIDs() const { return myLayerIds; }
 107
 108   //! Marks BVH tree for given priority list as dirty and
 109   //! marks primitive set for rebuild.
 110   void InvalidateBVHData (const Graphic3d_ZLayerId theLayerId);
 111
 112   //! Returns structure modification state (for ray-tracing).
 113   Standard_Size ModificationStateOfRaytracable() const { return myModifStateOfRaytraceable; }
 114
 115   //! Returns BVH tree builder for frustom culling.
 116   const Handle(Select3D_BVHBuilder3d)& FrustumCullingBVHBuilder() const { return myBVHBuilder; }
 117
 118   //! Assigns BVH tree builder for frustom culling.
 119   void SetFrustumCullingBVHBuilder (const Handle(Select3D_BVHBuilder3d)& theBuilder);
 120
 121 protected:
 122
 123   //! Filter of TKOpenGl elements for processing only shading geometry and
 124   //! for collecting number of skipped elements to an external counter.
 125   class OpenGl_OpaqueFilter : public OpenGl_RenderFilter
 126   {
 127   public:
 128
 129     //! Constructor.
 130     //! @param thePrevFilter [in] the previously active filter that should have additive effect.
 131     OpenGl_OpaqueFilter() : mySkippedCounter (0) {}
 132
 133     //! Sets the current active filter in workspace.
 134     //! @param thePrevFilter [in] the previously active filter that should have additive effect.
 135     void SetPreviousFilter (const Handle(OpenGl_RenderFilter)& thePrevFitler) { myFilter = thePrevFitler; }
 136
 137     //! Sets the value of the skipped elements counter.
 138     void SetSkippedCounter (const Standard_Size theCounter) { mySkippedCounter = theCounter; }
 139
 140     //! Returns number of skipped elements.
 141     Standard_Size NbSkipped() const { return mySkippedCounter; }
 142
 143     //! Checks whether the element should be rendered or skipped.
 144     //! @param theWorkspace [in] the currently used workspace for rendering.
 145     //! @param theGlElement [in] the TKOpenGl rendering queue element that should be checked before streaming to GPU.
 146     Standard_EXPORT virtual Standard_Boolean ShouldRender (const Handle(OpenGl_Workspace)& theWorkspace,
 147                                                            const OpenGl_Element*           theGlElement) Standard_OVERRIDE;
 148
 149     DEFINE_STANDARD_RTTI_INLINE (OpenGl_OpaqueFilter, OpenGl_RenderFilter)
 150
 151   private:
 152
 153     Standard_Size mySkippedCounter;   //!< Counter of skipped elements.
 154     Handle(OpenGl_RenderFilter) myFilter; //!< Previous active filter that should be combined.
 155   };
 156
 157   //! Filter of TKOpenGl elements for keeping only shading geometry with transparency.
 158   class OpenGl_TransparentFilter : public OpenGl_RenderFilter
 159   {
 160   public:
 161
 162     //! Constructor.
 163     OpenGl_TransparentFilter() {}
 164
 165     //! Sets the current active filter in workspace.
 166     //! @param thePrevFilter [in] the previously active filter that should have additive effect.
 167     void SetPreviousFilter (const Handle(OpenGl_RenderFilter)& thePrevFitler) { myFilter = thePrevFitler; }
 168
 169     //! Checks whether the element should be rendered or skipped.
 170     //! @param theWorkspace [in] the currently used workspace for rendering.
 171     //! @param theGlElement [in] the TKOpenGl rendering queue element that should be checked before streaming to GPU.
 172     Standard_EXPORT virtual Standard_Boolean ShouldRender (const Handle(OpenGl_Workspace)& theWorkspace,
 173                                                            const OpenGl_Element*           theGlElement) Standard_OVERRIDE;
 174
 175     DEFINE_STANDARD_RTTI_INLINE (OpenGl_TransparentFilter, OpenGl_RenderFilter)
 176
 177   private:
 178
 179     Handle(OpenGl_RenderFilter) myFilter; //!< Previous active filter that should be combined.
 180   };
 181
 182   //! Stack of references to existing layers of predefined maximum size.
 183   class OpenGl_LayerStack
 184   {
 185   public:
 186     typedef NCollection_Array1<const OpenGl_Layer*>::iterator iterator;
 187
 188     //! Reallocate internal buffer of the stack.
 189     void Allocate (Standard_Integer theSize)
 190     {
 191       if (theSize > 0)
 192       {
 193         myStackSpace = new NCollection_Array1<const OpenGl_Layer*> (1, theSize);
 194         myStackSpace->Init (NULL);
 195         myBackPtr    = myStackSpace->begin();
 196       }
 197       else
 198       {
 199         myStackSpace.Nullify();
 200         myBackPtr = iterator();
 201       }
 202     }
 203
 204     //! Clear stack.
 205     void Clear()
 206     {
 207       if (!myStackSpace.IsNull())
 208       {
 209         myStackSpace->Init (NULL);
 210         myBackPtr = myStackSpace->begin();
 211       }
 212     }
 213
 214     //! Push a new layer reference to the stack.
 215     void Push (const OpenGl_Layer* theLayer) { (*myBackPtr++) = theLayer; }
 216
 217     //! Returns iterator to the origin of the stack.
 218     iterator Origin() const { return myStackSpace.IsNull() ? iterator() : myStackSpace->begin(); }
 219
 220     //! Returns iterator to the back of the stack (after last item added).
 221     iterator Back() const { return myBackPtr; }
 222
 223     //! Returns true if nothing has been pushed into the stack.
 224     Standard_Boolean IsEmpty() const { return Back() == Origin(); }
 225
 226   private:
 227
 228     NCollection_Handle<NCollection_Array1<const OpenGl_Layer*> > myStackSpace;
 229     iterator                                                     myBackPtr;
 230   };
 231
 232   //! Render transparent objects using blending operator.
 233   //! Additional accumulation framebuffer is used for blended order-independent
 234   //! transparency algorithm. It should support floating-point color components
 235   //! and share depth with main reading/drawing framebuffer.
 236   //! @param theWorkspace [in] the currently used workspace for rendering.
 237   //! @param theLayerIter [in/out] the current iterator of transparent layers to process.
 238   //! @param theGlobalSettings [in] the set of global settings used for rendering.
 239   //! @param theReadDrawFbo [in] the framebuffer for reading depth and writing final color.
 240   //! @param theOitAccumFbo [in] the framebuffer for accumulating color and coverage for OIT process.
 241   void renderTransparent (const Handle(OpenGl_Workspace)&   theWorkspace,
 242                           OpenGl_LayerStack::iterator&      theLayerIter,
 243                           const OpenGl_GlobalLayerSettings& theGlobalSettings,
 244                           OpenGl_FrameBuffer*               theReadDrawFbo,
 245                           OpenGl_FrameBuffer*               theOitAccumFbo) const;
 246
 247 protected:
 248
 249   // number of structures temporary put to default layer
 250   OpenGl_SequenceOfLayers myLayers;
 251   OpenGl_LayerSeqIds      myLayerIds;
 252   Handle(Select3D_BVHBuilder3d) myBVHBuilder;      //!< BVH tree builder for frustom culling
 253   Standard_Integer        myDefaultLayerIndex;     //!< index of Graphic3d_ZLayerId_Default layer in myLayers sequence
 254
 255   Standard_Integer        myNbPriorities;
 256   Standard_Integer        myNbStructures;
 257   Standard_Integer        myImmediateNbStructures; //!< number of structures within immediate layers
 258
 259   mutable Standard_Size   myModifStateOfRaytraceable;
 260
 261   //! Collection of references to layers with transparency gathered during rendering pass.
 262   mutable OpenGl_LayerStack myTransparentToProcess;
 263
 264   Handle(OpenGl_OpaqueFilter)      myRenderOpaqueFilter; //!< rendering filter for opaque drawing pass (blended OIT).
 265   Handle(OpenGl_TransparentFilter) myRenderTranspFilter; //!< rendering filter for transparency drawing pass (blended OIT).
 266
 267 public:
 268
 269   DEFINE_STANDARD_ALLOC
 270
 271 };
 272
 273 #endif //_OpenGl_LayerList_Header