#include <dali/internal/update/manager/transform-manager-property.h>
#include <dali/internal/update/manager/transform-manager.h>
#include <dali/internal/update/nodes/node-declarations.h>
+#include <dali/internal/update/nodes/node-helper.h>
+#include <dali/internal/update/nodes/partial-rendering-data.h>
#include <dali/internal/update/rendering/scene-graph-renderer.h>
#include <dali/public-api/actors/actor-enumerations.h>
#include <dali/public-api/actors/draw-mode.h>
class Layer;
class RenderTask;
class UpdateManager;
+class Node;
// Flags which require the scene renderable lists to be updated
static NodePropertyFlags RenderableUpdateFlags = NodePropertyFlags::TRANSFORM | NodePropertyFlags::CHILD_DELETED;
* Query whether the node is a layer.
* @return True if the node is a layer.
*/
- bool IsLayer()
+ bool IsLayer() const
{
return mIsLayer;
}
return nullptr;
}
+ // Camera interface
+
+ /**
+ * Query whether the node is a camera.
+ * @return True if the node is a camera.
+ */
+ bool IsCamera() const
+ {
+ return mIsCamera;
+ }
+
/**
* Mark an node and its sub tree according to the updated flag.
* @param[in] updated The updated flag
void SetClippingMode(const ClippingMode::Type clippingMode)
{
mClippingMode = clippingMode;
+ SetDirtyFlag(NodePropertyFlags::TRANSFORM);
}
/**
if(depthIndex != mDepthIndex)
{
SetDirtyFlag(NodePropertyFlags::DEPTH_INDEX);
+ SetUpdated(true);
mDepthIndex = depthIndex;
}
}
return mCulled[bufferIndex];
}
+ /**
+ * @brief Get the total capacity of the memory pools
+ * @return The capacity of the memory pools
+ *
+ * @note This is different to the node count.
+ */
+ static uint32_t GetMemoryPoolCapacity();
+
+ /**
+ * @brief Returns partial rendering data associated with the node.
+ * @return The partial rendering data
+ */
+ PartialRenderingData& GetPartialRenderingData()
+ {
+ return mPartialRenderingData;
+ }
+
public:
/**
* @copydoc Dali::Internal::SceneGraph::PropertyOwner::IsAnimationPossible
*/
void ResetDirtyFlags(BufferIndex updateBufferIndex);
+ /**
+ * Update uniform hash
+ * @param[in] bufferIndex The buffer to read from.
+ */
+ void UpdateUniformHash(BufferIndex bufferIndex);
+
protected:
/**
* Set the parent of a Node.
private: // from NodeDataProvider
/**
- * @copydoc NodeDataProvider::GetModelMatrix
- */
- const Matrix& GetModelMatrix(BufferIndex bufferIndex) const override
- {
- return GetWorldMatrix(bufferIndex);
- }
-
- /**
* @copydoc NodeDataProvider::GetRenderColor
*/
const Vector4& GetRenderColor(BufferIndex bufferIndex) const override
}
private:
- // Undefined
- Node(const Node&);
-
- // Undefined
- Node& operator=(const Node& rhs);
+ // Delete copy and move
+ Node(const Node&) = delete;
+ Node(Node&&) = delete;
+ Node& operator=(const Node& rhs) = delete;
+ Node& operator=(Node&& rhs) = delete;
/**
* Recursive helper to disconnect a Node and its children.
void RecursiveDisconnectFromSceneGraph(BufferIndex updateBufferIndex);
public: // Default properties
- using TransformManagerParentsOrigin = TransformManagerPropertyVector3<TRANSFORM_PROPERTY_PARENT_ORIGIN>;
- using TransformManagerAnchorPoint = TransformManagerPropertyVector3<TRANSFORM_PROPERTY_ANCHOR_POINT>;
- using TransformManagerSize = TransformManagerPropertyVector3<TRANSFORM_PROPERTY_SIZE>;
- using TransformManagerPosition = TransformManagerPropertyVector3<TRANSFORM_PROPERTY_POSITION>;
- using TransformManagerScale = TransformManagerPropertyVector3<TRANSFORM_PROPERTY_SCALE>;
-
- TransformManagerData mTransformManagerData;
- TransformManagerParentsOrigin mParentOrigin; ///< Local transform; the position is relative to this. Sets the Transform flag dirty when changed
- TransformManagerAnchorPoint mAnchorPoint; ///< Local transform; local center of rotation. Sets the Transform flag dirty when changed
- TransformManagerSize mSize; ///< Size is provided for layouting
- TransformManagerPosition mPosition; ///< Local transform; distance between parent-origin & anchor-point
- TransformManagerScale mScale; ///< Local transform; scale relative to parent node
- TransformManagerPropertyQuaternion mOrientation; ///< Local transform; rotation relative to parent node
+ // Define a base offset for the following wrappers. The wrapper macros calculate offsets from the previous
+ // element such that each wrapper type generates a compile time offset to the transform manager data.
+ BASE(TransformManagerData, mTransformManagerData);
+ PROPERTY_WRAPPER(mTransformManagerData, TransformManagerPropertyVector3, TRANSFORM_PROPERTY_PARENT_ORIGIN,
+ mParentOrigin); // Local transform; the position is relative to this. Sets the Transform flag dirty when changed
+
+ PROPERTY_WRAPPER(mParentOrigin, TransformManagerPropertyVector3, TRANSFORM_PROPERTY_ANCHOR_POINT,
+ mAnchorPoint); // Local transform; local center of rotation. Sets the Transform flag dirty when changed
+
+ PROPERTY_WRAPPER(mAnchorPoint, TransformManagerPropertyVector3, TRANSFORM_PROPERTY_SIZE,
+ mSize); // Size is provided for layouting
+
+ PROPERTY_WRAPPER(mSize, TransformManagerPropertyVector3, TRANSFORM_PROPERTY_POSITION,
+ mPosition); // Local transform; distance between parent-origin & anchor-point
+ PROPERTY_WRAPPER(mPosition, TransformManagerPropertyVector3, TRANSFORM_PROPERTY_SCALE,
+ mScale); // Local transform; scale relative to parent node
+
+ TEMPLATE_WRAPPER(mScale, TransformManagerPropertyQuaternion,
+ mOrientation); // Local transform; rotation relative to parent node
+
+ // Inherited properties; read-only from public API
+ TEMPLATE_WRAPPER(mOrientation, TransformManagerVector3Input, mWorldPosition); // Full inherited position
+ TEMPLATE_WRAPPER(mWorldPosition, TransformManagerVector3Input, mWorldScale); // Full inherited scale
+ TEMPLATE_WRAPPER(mWorldScale, TransformManagerQuaternionInput, mWorldOrientation); // Full inherited orientation
+ TEMPLATE_WRAPPER(mWorldOrientation, TransformManagerMatrixInput, mWorldMatrix); // Full inherited world matrix
AnimatableProperty<bool> mVisible; ///< Visibility can be inherited from the Node hierachy
AnimatableProperty<bool> mCulled; ///< True if the node is culled. This is not animatable. It is just double-buffered.
AnimatableProperty<Vector4> mColor; ///< Color can be inherited from the Node hierarchy
+ InheritedColor mWorldColor; ///< Full inherited color
AnimatableProperty<Vector4> mUpdateAreaHint; ///< Update area hint is provided for damaged area calculation. (x, y, width, height)
///< This is not animatable. It is just double-buffered. (Because all these bloody properties are).
- // Inherited properties; read-only from public API
-
- TransformManagerVector3Input mWorldPosition; ///< Full inherited position
- TransformManagerVector3Input mWorldScale;
- TransformManagerQuaternionInput mWorldOrientation; ///< Full inherited orientation
- TransformManagerMatrixInput mWorldMatrix; ///< Full inherited world matrix
- InheritedColor mWorldColor; ///< Full inherited color
-
+ uint64_t mUniformsHash{0u}; ///< Hash of uniform map property values
uint32_t mClippingSortModifier; ///< Contains bit-packed clipping information for quick access when sorting
const uint32_t mId; ///< The Unique ID of the node.
protected:
static uint32_t mNodeCounter; ///< count of total nodes, used for unique ids
+ PartialRenderingData mPartialRenderingData; ///< Cache to determine if this should be rendered again
+
Node* mParent; ///< Pointer to parent node (a child is owned by its parent)
RenderTask* mExclusiveRenderTask; ///< Nodes can be marked as exclusive to a single RenderTask
uint32_t mClippingDepth; ///< The number of stencil clipping nodes deep this node is
uint32_t mScissorDepth; ///< The number of scissor clipping nodes deep this node is
-
- uint32_t mDepthIndex; ///< Depth index of the node
+ uint32_t mDepthIndex; ///< Depth index of the node
// flags, compressed to bitfield
NodePropertyFlags mDirtyFlags; ///< Dirty flags for each of the Node properties
ClippingMode::Type mClippingMode : 3; ///< The clipping mode of this node
bool mIsRoot : 1; ///< True if the node cannot have a parent
bool mIsLayer : 1; ///< True if the node is a layer
+ bool mIsCamera : 1; ///< True if the node is a camera
bool mPositionUsesAnchorPoint : 1; ///< True if the node should use the anchor-point when calculating the position
bool mTransparent : 1; ///< True if this node is transparent. This value do not affect children.