dali/internal/render/common/render-list.h

   1 #ifndef __DALI_INTERNAL_SCENE_GRAPH_RENDER_LIST_H__
   2 #define __DALI_INTERNAL_SCENE_GRAPH_RENDER_LIST_H__
   3
   4 /*
   5  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */
  20
  21 // INTERNAL INCLUDES
  22 #include <dali/public-api/math/rect.h>
  23 #include <dali/devel-api/common/owner-container.h>
  24 #include <dali/internal/render/common/render-item.h>
  25
  26 namespace Dali
  27 {
  28
  29 typedef Rect<int> ClippingBox;
  30
  31 namespace Internal
  32 {
  33
  34 namespace Render
  35 {
  36 class Renderer;
  37 }
  38
  39 namespace SceneGraph
  40 {
  41
  42 class Layer;
  43
  44 typedef OwnerContainer< RenderItem* > RenderItemContainer;
  45
  46 struct RenderList;
  47 typedef OwnerContainer< RenderList* > RenderListContainer;
  48
  49 /**
  50  * The RenderList structure provides the renderer with a list of renderers and
  51  * a set of flags to tell it what depth buffering is required.
  52  */
  53 struct RenderList
  54 {
  55 public:
  56
  57   /**
  58    * The RenderFlags describe how the objects are rendered using the stencil buffer.
  59    */
  60   enum RenderFlags
  61   {
  62     STENCIL_BUFFER_ENABLED = 1 << 0, ///< If stencil buffer should be used for writing / test operation
  63     STENCIL_WRITE          = 1 << 1, ///< If the stencil buffer is writable
  64     STENCIL_CLEAR          = 1 << 2, ///< If the stencil buffer should first be cleared
  65   };
  66
  67   /**
  68    * Constructor
  69    */
  70   RenderList()
  71   : mNextFree( 0 ),
  72     mRenderFlags( 0u ),
  73     mClippingBox( NULL ),
  74     mSourceLayer( NULL ),
  75     mHasColorRenderItems( false )
  76   {
  77   }
  78
  79   /**
  80    * Destructor
  81    */
  82   ~RenderList()
  83   {
  84     // pointer container deletes the render items
  85     delete mClippingBox;
  86   }
  87
  88   /**
  89    * Clear the render flags
  90    */
  91   void ClearFlags()
  92   {
  93     mRenderFlags = 0u;
  94   }
  95
  96   /**
  97    * Set particular render flags
  98    * @param[in] flags The set of flags to bitwise or with existing flags
  99    */
 100   void SetFlags( unsigned int flags )
 101   {
 102     mRenderFlags |= flags;
 103   }
 104
 105   /**
 106    * Retrieve the render flags.
 107    * @return the render flags.
 108    */
 109   unsigned int GetFlags() const
 110   {
 111     return mRenderFlags;
 112   }
 113
 114   /**
 115    * Reset the render list for next frame
 116    */
 117   void Reset()
 118   {
 119     // we dont want to delete and re-create the render items every frame
 120     mNextFree = 0;
 121     mRenderFlags = 0u;
 122
 123     delete mClippingBox;
 124     mClippingBox = NULL;
 125   }
 126
 127   /**
 128    * Reserve space in the render list
 129    * @param size to reserve
 130    */
 131   void Reserve( RenderItemContainer::SizeType size )
 132   {
 133     mNextFree = 0;
 134     mItems.Reserve( size );
 135   }
 136
 137   /**
 138    * @return the capacity of the render list
 139    */
 140   RenderItemContainer::SizeType Capacity()
 141   {
 142     return mItems.Capacity();
 143   }
 144
 145   /**
 146    * Get next free render item
 147    * @return reference to the next available RenderItem
 148    */
 149   RenderItem& GetNextFreeItem()
 150   {
 151     // check if we have enough items, we can only be one behind at worst
 152     if( mItems.Count() <= mNextFree )
 153     {
 154       mItems.PushBack( RenderItem::New() ); // Push a new empty render item
 155     }
 156     // get the item mNextFree points to and increase by one
 157     RenderItem& item = *mItems[ mNextFree++ ];
 158     return item;
 159   }
 160
 161   /**
 162    * Get item at a given position in the list
 163    */
 164   RenderItem& GetItem( RenderItemContainer::SizeType index ) const
 165   {
 166     DALI_ASSERT_DEBUG( index < GetCachedItemCount() );
 167     return *mItems[ index ];
 168   }
 169
 170   /**
 171    * Get renderer from an item in the list
 172    */
 173   const Render::Renderer& GetRenderer( RenderItemContainer::SizeType index ) const
 174   {
 175     DALI_ASSERT_DEBUG( index < GetCachedItemCount() );
 176     return *mItems[ index ]->mRenderer;
 177   }
 178
 179   /**
 180    * Get the number of real items
 181    * Because of caching, the actual size may be bit more
 182    * @return The number of items
 183    */
 184   RenderItemContainer::SizeType Count() const
 185   {
 186     return mNextFree;
 187   }
 188
 189   /**
 190    * @return the number of items cached by the list
 191    */
 192   RenderItemContainer::SizeType GetCachedItemCount() const
 193   {
 194     return mItems.Count();
 195   }
 196
 197   /**
 198    * Tells the render list to reuse the items from the cache
 199    */
 200   void ReuseCachedItems()
 201   {
 202     mNextFree = mItems.Count();
 203   }
 204
 205   /**
 206    * Predicate to inform if the list is empty
 207    */
 208   bool IsEmpty() const
 209   {
 210     return (mNextFree == 0);
 211   }
 212
 213   /**
 214    * Set clipping
 215    * @param clipping on/off
 216    * @param box for clipping
 217    */
 218   void SetClipping( bool clipping, const ClippingBox& box )
 219   {
 220     if( clipping )
 221     {
 222       ClippingBox* newBox = new ClippingBox( box );
 223       delete mClippingBox;
 224       mClippingBox = newBox;
 225     }
 226   }
 227
 228   /**
 229    * @return true if clipping is on
 230    */
 231   bool IsClipping() const
 232   {
 233     return (NULL != mClippingBox);
 234   }
 235
 236   /**
 237    * @return the clipping box
 238    */
 239   const ClippingBox& GetClippingBox() const
 240   {
 241     return *mClippingBox;
 242   }
 243
 244   /**
 245    * @return the container (for sorting)
 246    */
 247   RenderItemContainer& GetContainer()
 248   {
 249     return mItems;
 250   }
 251
 252   /**
 253    * Do some housekeeping to keep memory consumption low
 254    */
 255   void ReleaseUnusedItems()
 256   {
 257     // release any non-used RenderItems
 258     if( mItems.Count() > mNextFree )
 259     {
 260       mItems.Resize( mNextFree );
 261     }
 262   }
 263
 264   /**
 265    * @return the source layer these renderitems originate from
 266    */
 267   Layer* GetSourceLayer() const
 268   {
 269     return mSourceLayer;
 270   }
 271
 272   /**
 273    * @param layer The layer these RenderItems originate from
 274    */
 275   void SetSourceLayer( Layer* layer )
 276   {
 277     mSourceLayer = layer;
 278   }
 279
 280   /**
 281    * Set if the RenderList contains color RenderItems
 282    * @param[in] hasColorRenderItems True if it contains color RenderItems, false otherwise
 283    */
 284   void SetHasColorRenderItems( bool hasColorRenderItems )
 285   {
 286     mHasColorRenderItems = hasColorRenderItems;
 287   }
 288
 289   /**
 290    * Check if the RenderList contains color RenderItems
 291    * @return true if the RenderList contains color RenderItems, false otherwise
 292    */
 293   bool HasColorRenderItems() const
 294   {
 295     return mHasColorRenderItems;
 296   }
 297
 298 private:
 299
 300   /*
 301    * Copy constructor and assignment operator not defined
 302    */
 303   RenderList( const RenderList& rhs );
 304   const RenderList& operator=( const RenderList& rhs );
 305
 306   RenderItemContainer mItems; ///< Each item is a renderer and matrix pair
 307   RenderItemContainer::SizeType mNextFree;              ///< index for the next free item to use
 308
 309   unsigned int mRenderFlags;    ///< The render flags
 310
 311   ClippingBox* mClippingBox;               ///< The clipping box, in window coordinates, when clipping is enabled
 312   Layer*       mSourceLayer;              ///< The originating layer where the renderers are from
 313   bool         mHasColorRenderItems : 1;  ///< True if list contains color render items
 314 };
 315
 316 } // namespace SceneGraph
 317
 318 } // namespace Internal
 319
 320 } // namespace Dali
 321
 322 #endif // __DALI_INTERNAL_SCENE_GRAPH_RENDER_LIST_H__