dali/internal/update/nodes/scene-graph-layer.h

   1 #ifndef __DALI_INTERNAL_SCENE_GRAPH_LAYER_H__
   2 #define __DALI_INTERNAL_SCENE_GRAPH_LAYER_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/actors/layer.h>
  23 #include <dali/internal/event/common/event-thread-services.h>
  24 #include <dali/internal/update/nodes/node.h>
  25 #include <dali/internal/update/node-attachments/scene-graph-renderable-attachment-declarations.h>
  26
  27 namespace Dali
  28 {
  29
  30 namespace Internal
  31 {
  32
  33 class RenderableAttachment;
  34
  35 // value types used by messages
  36 template <> struct ParameterType< Dali::Layer::SortFunctionType >
  37 : public BasicType< Dali::Layer::SortFunctionType > {};
  38 template <> struct ParameterType< Dali::Layer::Behavior >
  39 : public BasicType< Dali::Layer::Behavior > {};
  40
  41 namespace SceneGraph
  42 {
  43
  44 /**
  45  * Pair of node-renderer
  46  */
  47 struct NodeRenderer
  48 {
  49   NodeRenderer()
  50   :mNode(0),
  51    mRenderer(0)
  52   {}
  53
  54   NodeRenderer( Node* node, Renderer* renderer )
  55   :mNode(node),
  56    mRenderer(renderer)
  57   {}
  58
  59   Node* mNode;
  60   Renderer* mRenderer;
  61 };
  62
  63 typedef Dali::Vector< NodeRenderer > NodeRendererContainer;
  64
  65 /**
  66  * Layers have a "depth" relative to all other layers in the scene-graph.
  67  * Non-layer child nodes (and their attachments) are considered part of the layer.
  68  *
  69  * Layers are rendered separately, and the depth buffer is cleared before each layer is rendered.
  70  * Objects in higher layers, are rendered after (in front of) objects in lower layers.
  71  */
  72 class Layer : public Node
  73 {
  74 public:
  75
  76   typedef Dali::Layer::SortFunctionType SortFunctionType;
  77
  78   // Creation methods
  79
  80   /**
  81    * Construct a new Layer.
  82    * @return A smart-pointer to a newly allocated Node
  83    */
  84   static SceneGraph::Layer* New();
  85
  86   /**
  87    * Virtual destructor
  88    */
  89   virtual ~Layer();
  90
  91   /**
  92    * From Node, to convert a node to a layer.
  93    * @return The layer.
  94    */
  95   virtual Layer* GetLayer()
  96   {
  97     return this;
  98   }
  99
 100   /**
 101    * Sets the sort-function of a layer.
 102    * @param [in] function The new sort-function.
 103    */
 104   void SetSortFunction( Dali::Layer::SortFunctionType function );
 105
 106   /**
 107    * Retrieve the function used to sort semi-transparent geometry in this layer.
 108    * @return The sort function.
 109    */
 110   Dali::Layer::SortFunctionType GetSortFunction() const
 111   {
 112     return mSortFunction;
 113   }
 114
 115   /**
 116    * Sets whether clipping is enabled for a layer.
 117    * @param [in] enabled True if clipping is enabled.
 118    */
 119   void SetClipping( bool enabled );
 120
 121   /**
 122    * Query whether clipping is enabled for a layer.
 123    * @return True if clipping is enabled.
 124    */
 125   bool IsClipping() const
 126   {
 127     return mIsClipping;
 128   }
 129
 130   /**
 131    * Sets the clipping box of a layer, in window coordinates.
 132    * The contents of the layer will not be visible outside this box, when clipping is
 133    * enabled. The default clipping box is empty (0,0,0,0).
 134    * @param [in] box The clipping box
 135    */
 136   void SetClippingBox( const ClippingBox& box );
 137
 138   /**
 139    * Retrieves the clipping box of a layer, in window coordinates.
 140    * @return The clipping box
 141    */
 142   const ClippingBox& GetClippingBox() const
 143   {
 144     return mClippingBox;
 145   }
 146
 147   /**
 148    * Sets the behavior of the layer
 149    * @param [in] behavior The behavior of the layer
 150    */
 151   void SetBehavior( Dali::Layer::Behavior behavior );
 152
 153   /**
 154    * Retrieves the behavior of the layer.
 155    * @return The behavior
 156    */
 157   Dali::Layer::Behavior GetBehavior() const
 158   {
 159     return mBehavior;
 160   }
 161
 162   /**
 163    * @copydoc Dali::Layer::SetDepthTestDisabled()
 164    */
 165   void SetDepthTestDisabled( bool disable );
 166
 167   /**
 168    * @copydoc Dali::Layer::IsDepthTestDisabled()
 169    */
 170   bool IsDepthTestDisabled() const;
 171
 172   /**
 173    * Enables the reuse of the model view matrices of all renderers for this layer
 174    * @param[in] updateBufferIndex The current update buffer index.
 175    * @param value to set
 176    */
 177   void SetReuseRenderers( BufferIndex updateBufferIndex, bool value )
 178   {
 179     mAllChildTransformsClean[ updateBufferIndex ] = value;
 180   }
 181
 182   /**
 183    * Checks if it is ok to reuse renderers. Renderers can be reused if ModelView transform for all the renderers
 184    * has not changed from previous use.
 185    * @param[in] camera A pointer to the camera that we want to use to render the list.
 186    * @return True if all children transforms have been clean for two consecutive frames and the camera we are going
 187    * to use is the same than the one used before ( Otherwise View transform will be different )
 188    *
 189    */
 190   bool CanReuseRenderers(Node* camera)
 191   {
 192     bool bReturn( mAllChildTransformsClean[ 0 ] && mAllChildTransformsClean[ 1 ] && camera == mLastCamera );
 193     mLastCamera = camera;
 194
 195     return bReturn;
 196   }
 197
 198   /**
 199    * @return True if default sort function is used
 200    */
 201   bool UsesDefaultSortFunction()
 202   {
 203     return mIsDefaultSortFunction;
 204   }
 205
 206 private:
 207
 208   /**
 209    * Private constructor.
 210    * See also Layer::New()
 211    */
 212   Layer();
 213
 214   // Undefined
 215   Layer(const Layer&);
 216
 217   // Undefined
 218   Layer& operator=(const Layer& rhs);
 219
 220 public: // For update-algorithms
 221
 222   RenderableAttachmentContainer stencilRenderables;
 223   RenderableAttachmentContainer colorRenderables;
 224   RenderableAttachmentContainer overlayRenderables;
 225
 226   NodeRendererContainer stencilRenderers;
 227   NodeRendererContainer colorRenderers;
 228   NodeRendererContainer overlayRenderers;
 229
 230 private:
 231
 232   SortFunctionType mSortFunction; ///< Used to sort semi-transparent geometry
 233
 234   ClippingBox mClippingBox;           ///< The clipping box, in window coordinates
 235   Node* mLastCamera;                  ///< Pointer to the last camera that has rendered the layer
 236
 237   Dali::Layer::Behavior mBehavior;    ///< The behavior of the layer
 238
 239   bool mAllChildTransformsClean[ 2 ]; ///< True if all child nodes transforms are clean,
 240                                       /// double buffered as we need two clean frames before we can reuse N-1 for N+1
 241                                       /// this allows us to cache render items when layer is "static"
 242   bool mIsClipping:1;                 ///< True when clipping is enabled
 243   bool mDepthTestDisabled:1;          ///< Whether depth test is disabled.
 244   bool mIsDefaultSortFunction:1;      ///< whether the default depth sort function is used
 245
 246 };
 247
 248 // Messages for Layer
 249
 250 /**
 251  * Create a message to set the sort-function of a layer
 252  * @param[in] layer The layer
 253  * @param[in] function The new sort-function.
 254  */
 255 inline void SetSortFunctionMessage( EventThreadServices& eventThreadServices, const Layer& layer, Dali::Layer::SortFunctionType function )
 256 {
 257   typedef MessageValue1< Layer, Dali::Layer::SortFunctionType > LocalType;
 258
 259   // Reserve some memory inside the message queue
 260   unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
 261
 262   // Construct message in the message queue memory; note that delete should not be called on the return value
 263   new (slot) LocalType( &layer, &Layer::SetSortFunction, function );
 264 }
 265
 266 /**
 267  * Create a message for enabling/disabling layer clipping
 268  * @param[in] layer The layer
 269  * @param[in] enabled True if clipping is enabled
 270  */
 271 inline void SetClippingMessage( EventThreadServices& eventThreadServices, const Layer& layer, bool enabled )
 272 {
 273   typedef MessageValue1< Layer, bool > LocalType;
 274
 275   // Reserve some memory inside the message queue
 276   unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
 277
 278   // Construct message in the message queue memory; note that delete should not be called on the return value
 279   new (slot) LocalType( &layer, &Layer::SetClipping, enabled );
 280 }
 281
 282 /**
 283  * Create a message to set the clipping box of a layer
 284  * @param[in] layer The layer
 285  * @param[in] clippingbox The clipping box
 286  */
 287 inline void SetClippingBoxMessage( EventThreadServices& eventThreadServices, const Layer& layer, const Dali::ClippingBox& clippingbox )
 288 {
 289   typedef MessageValue1< Layer, Dali::ClippingBox > LocalType;
 290
 291   // Reserve some memory inside the message queue
 292   unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
 293
 294   // Construct message in the message queue memory; note that delete should not be called on the return value
 295   new (slot) LocalType( &layer, &Layer::SetClippingBox, clippingbox );
 296 }
 297
 298 /**
 299  * Create a message to set the behavior of a layer
 300  * @param[in] layer The layer
 301  * @param[in] behavior The behavior
 302  */
 303 inline void SetBehaviorMessage( EventThreadServices& eventThreadServices,
 304                                 const Layer& layer,
 305                                 Dali::Layer::Behavior behavior )
 306 {
 307   typedef MessageValue1< Layer, Dali::Layer::Behavior > LocalType;
 308
 309   // Reserve some memory inside the message queue
 310   unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
 311
 312   // Construct message in the message queue memory; note that delete should not be called on the return value
 313   new (slot) LocalType( &layer, &Layer::SetBehavior, behavior );
 314 }
 315
 316 /**
 317  * Create a message for disabling/enabling depth test.
 318  *
 319  * @see Dali::Layer::SetDepthTestDisabled().
 320  *
 321  * @param[in] layer The layer
 322  * @param[in] disable \e true disables depth test. \e false sets the default behavior.
 323  */
 324 inline void SetDepthTestDisabledMessage( EventThreadServices& eventThreadServices, const Layer& layer, bool disable )
 325 {
 326   typedef MessageValue1< Layer, bool > LocalType;
 327
 328   // Reserve some memory inside the message queue
 329   unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
 330
 331   // Construct message in the message queue memory; note that delete should not be called on the return value
 332   new (slot) LocalType( &layer, &Layer::SetDepthTestDisabled, disable );
 333 }
 334
 335 } // namespace SceneGraph
 336
 337 } // namespace Internal
 338
 339 } // namespace Dali
 340
 341 #endif // __DALI_INTERNAL_SCENE_GRAPH_LAYER_H__