-#ifndef __DALI_INTERNAL_SCENE_GRAPH_LAYER_H__
-#define __DALI_INTERNAL_SCENE_GRAPH_LAYER_H__
+#ifndef DALI_INTERNAL_SCENE_GRAPH_LAYER_H
+#define DALI_INTERNAL_SCENE_GRAPH_LAYER_H
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <dali/public-api/actors/layer.h>
#include <dali/internal/event/common/event-thread-services.h>
#include <dali/internal/update/nodes/node.h>
-#include <dali/internal/update/node-attachments/scene-graph-renderable-attachment-declarations.h>
namespace Dali
{
namespace Internal
{
-class RenderableAttachment;
-
// value types used by messages
template <> struct ParameterType< Dali::Layer::SortFunctionType >
: public BasicType< Dali::Layer::SortFunctionType > {};
namespace SceneGraph
{
+class Camera;
/**
* Pair of node-renderer
*/
-struct NodeRenderer
+struct Renderable
{
- NodeRenderer()
- :mNode(0),
- mRenderer(0)
+ Renderable()
+ : mNode( 0 ),
+ mRenderer( 0 )
{}
- NodeRenderer( Node* node, Renderer* renderer )
- :mNode(node),
- mRenderer(renderer)
+ Renderable( Node* node, Renderer* renderer )
+ : mNode( node ),
+ mRenderer( renderer )
{}
Node* mNode;
Renderer* mRenderer;
};
-typedef Dali::Vector< NodeRenderer > NodeRendererContainer;
+typedef Dali::Vector< Renderable > RenderableContainer;
/**
* Layers have a "depth" relative to all other layers in the scene-graph.
- * Non-layer child nodes (and their attachments) are considered part of the layer.
+ * Non-layer child nodes are considered part of the layer.
*
- * Layers are rendered separately, and the depth buffer is cleared before each layer is rendered.
+ * Layers are rendered separately, and by default the depth buffer is cleared before each layer is rendered.
* Objects in higher layers, are rendered after (in front of) objects in lower layers.
*/
class Layer : public Node
static SceneGraph::Layer* New();
/**
- * Virtual destructor
- */
- virtual ~Layer();
-
- /**
* From Node, to convert a node to a layer.
* @return The layer.
*/
* to use is the same than the one used before ( Otherwise View transform will be different )
*
*/
- bool CanReuseRenderers(Node* camera)
+ bool CanReuseRenderers( Camera* camera )
{
bool bReturn( mAllChildTransformsClean[ 0 ] && mAllChildTransformsClean[ 1 ] && camera == mLastCamera );
mLastCamera = camera;
return mIsDefaultSortFunction;
}
+ /**
+ * Clears all the renderable lists
+ */
+ void ClearRenderables();
+
private:
/**
// Undefined
Layer(const Layer&);
+ /**
+ * Virtual destructor
+ */
+ virtual ~Layer();
+
// Undefined
Layer& operator=(const Layer& rhs);
public: // For update-algorithms
- RenderableAttachmentContainer stencilRenderables;
- RenderableAttachmentContainer colorRenderables;
- RenderableAttachmentContainer overlayRenderables;
-
- NodeRendererContainer stencilRenderers;
- NodeRendererContainer colorRenderers;
- NodeRendererContainer overlayRenderers;
+ RenderableContainer colorRenderables;
+ RenderableContainer overlayRenderables;
private:
- SortFunctionType mSortFunction; ///< Used to sort semi-transparent geometry
+ SortFunctionType mSortFunction; ///< Used to sort semi-transparent geometry
ClippingBox mClippingBox; ///< The clipping box, in window coordinates
- Node* mLastCamera; ///< Pointer to the last camera that has rendered the layer
+ Camera* mLastCamera; ///< Pointer to the last camera that has rendered the layer
Dali::Layer::Behavior mBehavior; ///< The behavior of the layer
bool mAllChildTransformsClean[ 2 ]; ///< True if all child nodes transforms are clean,
- /// double buffered as we need two clean frames before we can reuse N-1 for N+1
- /// this allows us to cache render items when layer is "static"
+ /// double buffered as we need two clean frames before we can reuse N-1 for N+1
+ /// this allows us to cache render items when layer is "static"
bool mIsClipping:1; ///< True when clipping is enabled
bool mDepthTestDisabled:1; ///< Whether depth test is disabled.
bool mIsDefaultSortFunction:1; ///< whether the default depth sort function is used
} // namespace SceneGraph
+// Template specialisation for OwnerPointer<Layer>, because delete is protected
+template <>
+void OwnerPointer<Dali::Internal::SceneGraph::Layer>::Reset();
+
} // namespace Internal
} // namespace Dali
-#endif // __DALI_INTERNAL_SCENE_GRAPH_LAYER_H__
+#endif // DALI_INTERNAL_SCENE_GRAPH_LAYER_H