1 #ifndef DALI_INTERNAL_SCENE_GRAPH_LAYER_H
2 #define DALI_INTERNAL_SCENE_GRAPH_LAYER_H
5 * Copyright (c) 2018 Samsung Electronics Co., Ltd.
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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.
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>
32 // value types used by messages
33 template <> struct ParameterType< Dali::Layer::SortFunctionType >
34 : public BasicType< Dali::Layer::SortFunctionType > {};
35 template <> struct ParameterType< Dali::Layer::Behavior >
36 : public BasicType< Dali::Layer::Behavior > {};
43 * Pair of node-renderer
52 Renderable( Node* node, Renderer* renderer )
61 using RenderableContainer = Dali::Vector<Renderable>;
64 * Layers have a "depth" relative to all other layers in the scene-graph.
65 * Non-layer child nodes are considered part of the layer.
67 * Layers are rendered separately, and by default the depth buffer is cleared before each layer is rendered.
68 * Objects in higher layers, are rendered after (in front of) objects in lower layers.
70 class Layer : public Node
73 using SortFunctionType = Dali::Layer::SortFunctionType;
78 * Construct a new Layer.
79 * @return A smart-pointer to a newly allocated Node
81 static SceneGraph::Layer* New();
89 * From Node, to convert a node to a layer.
92 Layer* GetLayer() override
98 * Sets the sort-function of a layer.
99 * @param [in] function The new sort-function.
101 void SetSortFunction( Dali::Layer::SortFunctionType function );
104 * Retrieve the function used to sort semi-transparent geometry in this layer.
105 * @return The sort function.
107 Dali::Layer::SortFunctionType GetSortFunction() const
109 return mSortFunction;
113 * Sets whether clipping is enabled for a layer.
114 * @param [in] enabled True if clipping is enabled.
116 void SetClipping( bool enabled );
119 * Query whether clipping is enabled for a layer.
120 * @return True if clipping is enabled.
122 bool IsClipping() const
128 * Sets the clipping box of a layer, in window coordinates.
129 * The contents of the layer will not be visible outside this box, when clipping is
130 * enabled. The default clipping box is empty (0,0,0,0).
131 * @param [in] box The clipping box
133 void SetClippingBox( const ClippingBox& box );
136 * Retrieves the clipping box of a layer, in window coordinates.
137 * @return The clipping box
139 const ClippingBox& GetClippingBox() const
145 * Sets the behavior of the layer
146 * @param [in] behavior The behavior of the layer
148 void SetBehavior( Dali::Layer::Behavior behavior );
151 * Retrieves the behavior of the layer.
152 * @return The behavior
154 Dali::Layer::Behavior GetBehavior() const
160 * @copydoc Dali::Layer::SetDepthTestDisabled()
162 void SetDepthTestDisabled( bool disable );
165 * @copydoc Dali::Layer::IsDepthTestDisabled()
167 bool IsDepthTestDisabled() const;
170 * Enables the reuse of the model view matrices of all renderers for this layer
171 * @param[in] updateBufferIndex The current update buffer index.
172 * @param value to set
174 void SetReuseRenderers( BufferIndex updateBufferIndex, bool value )
176 mAllChildTransformsClean[ updateBufferIndex ] = value;
180 * Checks if it is ok to reuse renderers. Renderers can be reused if ModelView transform for all the renderers
181 * has not changed from previous use.
182 * @param[in] camera A pointer to the camera that we want to use to render the list.
183 * @return True if all children transforms have been clean for two consecutive frames and the camera we are going
184 * to use is the same than the one used before ( Otherwise View transform will be different )
187 bool CanReuseRenderers( Camera* camera )
189 bool bReturn( mAllChildTransformsClean[ 0 ] && mAllChildTransformsClean[ 1 ] && camera == mLastCamera );
190 mLastCamera = camera;
196 * @return True if default sort function is used
198 bool UsesDefaultSortFunction()
200 return mIsDefaultSortFunction;
204 * Clears all the renderable lists
206 void ClearRenderables();
211 * Private constructor.
212 * See also Layer::New()
220 Layer& operator=(const Layer& rhs);
222 public: // For update-algorithms
224 RenderableContainer colorRenderables;
225 RenderableContainer overlayRenderables;
229 SortFunctionType mSortFunction; ///< Used to sort semi-transparent geometry
231 ClippingBox mClippingBox; ///< The clipping box, in window coordinates
232 Camera* mLastCamera; ///< Pointer to the last camera that has rendered the layer
234 Dali::Layer::Behavior mBehavior; ///< The behavior of the layer
236 bool mAllChildTransformsClean[ 2 ]; ///< True if all child nodes transforms are clean,
237 /// double buffered as we need two clean frames before we can reuse N-1 for N+1
238 /// this allows us to cache render items when layer is "static"
239 bool mIsClipping:1; ///< True when clipping is enabled
240 bool mDepthTestDisabled:1; ///< Whether depth test is disabled.
241 bool mIsDefaultSortFunction:1; ///< whether the default depth sort function is used
245 // Messages for Layer
248 * Create a message to set the sort-function of a layer
249 * @param[in] layer The layer
250 * @param[in] function The new sort-function.
252 inline void SetSortFunctionMessage( EventThreadServices& eventThreadServices, const Layer& layer, Dali::Layer::SortFunctionType function )
254 using LocalType = MessageValue1<Layer, Dali::Layer::SortFunctionType>;
256 // Reserve some memory inside the message queue
257 uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
259 // Construct message in the message queue memory; note that delete should not be called on the return value
260 new (slot) LocalType( &layer, &Layer::SetSortFunction, function );
264 * Create a message for enabling/disabling layer clipping
265 * @param[in] layer The layer
266 * @param[in] enabled True if clipping is enabled
268 inline void SetClippingMessage( EventThreadServices& eventThreadServices, const Layer& layer, bool enabled )
270 using LocalType = MessageValue1<Layer, bool>;
272 // Reserve some memory inside the message queue
273 uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
275 // Construct message in the message queue memory; note that delete should not be called on the return value
276 new (slot) LocalType( &layer, &Layer::SetClipping, enabled );
280 * Create a message to set the clipping box of a layer
281 * @param[in] layer The layer
282 * @param[in] clippingbox The clipping box
284 inline void SetClippingBoxMessage( EventThreadServices& eventThreadServices, const Layer& layer, const Dali::ClippingBox& clippingbox )
286 using LocalType = MessageValue1<Layer, Dali::ClippingBox>;
288 // Reserve some memory inside the message queue
289 uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
291 // Construct message in the message queue memory; note that delete should not be called on the return value
292 new (slot) LocalType( &layer, &Layer::SetClippingBox, clippingbox );
296 * Create a message to set the behavior of a layer
297 * @param[in] layer The layer
298 * @param[in] behavior The behavior
300 inline void SetBehaviorMessage( EventThreadServices& eventThreadServices,
302 Dali::Layer::Behavior behavior )
304 using LocalType = MessageValue1<Layer, Dali::Layer::Behavior>;
306 // Reserve some memory inside the message queue
307 uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
309 // Construct message in the message queue memory; note that delete should not be called on the return value
310 new (slot) LocalType( &layer, &Layer::SetBehavior, behavior );
314 * Create a message for disabling/enabling depth test.
316 * @see Dali::Layer::SetDepthTestDisabled().
318 * @param[in] layer The layer
319 * @param[in] disable \e true disables depth test. \e false sets the default behavior.
321 inline void SetDepthTestDisabledMessage( EventThreadServices& eventThreadServices, const Layer& layer, bool disable )
323 using LocalType = MessageValue1<Layer, bool>;
325 // Reserve some memory inside the message queue
326 uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
328 // Construct message in the message queue memory; note that delete should not be called on the return value
329 new (slot) LocalType( &layer, &Layer::SetDepthTestDisabled, disable );
332 } // namespace SceneGraph
334 // Template specialisation for OwnerPointer<Layer>, because delete is protected
336 inline void OwnerPointer<Dali::Internal::SceneGraph::Layer>::Reset()
338 if (mObject != nullptr)
340 Dali::Internal::SceneGraph::Node::Delete(mObject);
344 } // namespace Internal
348 #endif // DALI_INTERNAL_SCENE_GRAPH_LAYER_H