X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fupdate%2Fmanager%2Fupdate-algorithms.cpp;h=7cd6ac6beac227c4a00e234d70d0ee2c4d1c7c69;hb=5de727a5d6b9ef995c93eff4d4e47a086784a332;hp=6a2d8ed6636e404af8ffba9f2f8ef96d53a55bd4;hpb=7882128f66bc91dbca9573caddd312115be440c4;p=platform%2Fcore%2Fuifw%2Fdali-core.git diff --git a/dali/internal/update/manager/update-algorithms.cpp b/dali/internal/update/manager/update-algorithms.cpp index 6a2d8ed..7cd6ac6 100644 --- a/dali/internal/update/manager/update-algorithms.cpp +++ b/dali/internal/update/manager/update-algorithms.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2014 Samsung Electronics Co., Ltd. + * Copyright (c) 2022 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. @@ -22,28 +22,22 @@ #include // INTERNAL INCLUDES +#include +#include +#include +#include #include #include #include -#include -#include -#include -#include -#include -#include -#include #include namespace Dali { - namespace Internal { - namespace SceneGraph { - #if defined(DEBUG_ENABLED) Debug::Filter* gUpdateFilter = Debug::Filter::New(Debug::Concise, false, "LOG_UPDATE_ALGORITHMS"); #endif @@ -52,58 +46,20 @@ Debug::Filter* gUpdateFilter = Debug::Filter::New(Debug::Concise, false, "LOG_UP *********************** Apply Constraints ************************************ ******************************************************************************/ - /** * Constrain the local properties of the PropertyOwner. * @param propertyOwner to constrain * @param updateBufferIndex buffer index to use - * @return The number of constraints that are still being applied */ -void ConstrainPropertyOwner( PropertyOwner& propertyOwner, BufferIndex updateBufferIndex ) +void ConstrainPropertyOwner(PropertyOwner& propertyOwner, BufferIndex updateBufferIndex) { ConstraintOwnerContainer& constraints = propertyOwner.GetConstraints(); const ConstraintIter endIter = constraints.End(); - for( ConstraintIter iter = constraints.Begin(); iter != endIter; ++iter ) + for(ConstraintIter iter = constraints.Begin(); iter != endIter; ++iter) { ConstraintBase& constraint = **iter; - constraint.Apply( updateBufferIndex ); - } -} - -/** - * Recursively apply the constraints on the nodes - * @param node to constraint - * @param updateBufferIndex buffer index to use - * @return number of active constraints - */ -void ConstrainNodes( Node& node, BufferIndex updateBufferIndex ) -{ - ConstrainPropertyOwner( node, updateBufferIndex ); - - if( node.HasAttachment() ) - { - // @todo MESH_REWORK Remove dynamic cast. - // (Or, if RendererAttachment split into RendererPropertyOwner(?), - // do as separate pass as per other mesh objects - see also - // UpdateManager::ResetNodeProperty()) - NodeAttachment& attachment = node.GetAttachment(); - PropertyOwner* propertyOwner = dynamic_cast< PropertyOwner* >( &attachment ); - if( propertyOwner != NULL ) - { - ConstrainPropertyOwner( *propertyOwner, updateBufferIndex ); - } - } - - /** - * Constrain the children next - */ - NodeContainer& children = node.GetChildren(); - const NodeIter endIter = children.End(); - for ( NodeIter iter = children.Begin(); iter != endIter; ++iter ) - { - Node& child = **iter; - ConstrainNodes( child, updateBufferIndex ); + constraint.Apply(updateBufferIndex); } } @@ -111,374 +67,191 @@ void ConstrainNodes( Node& node, BufferIndex updateBufferIndex ) ************************** Update node hierarchy ***************************** ******************************************************************************/ -inline void UpdateRootNodeOpacity( Layer& rootNode, int nodeDirtyFlags, BufferIndex updateBufferIndex ) +inline void UpdateRootNodeOpacity(Layer& rootNode, NodePropertyFlags nodeDirtyFlags, BufferIndex updateBufferIndex) { - if ( nodeDirtyFlags & ColorFlag ) + if(nodeDirtyFlags & NodePropertyFlags::COLOR) { - rootNode.SetWorldColor( rootNode.GetColor( updateBufferIndex ), updateBufferIndex ); + rootNode.SetWorldColor(rootNode.GetColor(updateBufferIndex), updateBufferIndex); } else { // Copy previous value, in case it changed in the previous frame - rootNode.CopyPreviousWorldColor( updateBufferIndex ); + rootNode.CopyPreviousWorldColor(updateBufferIndex); } } -inline void UpdateNodeOpacity( Node& node, int nodeDirtyFlags, BufferIndex updateBufferIndex ) +inline void UpdateNodeOpacity(Node& node, NodePropertyFlags nodeDirtyFlags, BufferIndex updateBufferIndex) { // If opacity needs to be recalculated - if ( nodeDirtyFlags & ColorFlag ) + if(nodeDirtyFlags & NodePropertyFlags::COLOR) { - node.InheritWorldColor( updateBufferIndex ); + node.InheritWorldColor(updateBufferIndex); } else { // Copy inherited value, if changed in the previous frame - node.CopyPreviousWorldColor( updateBufferIndex ); - } -} - -inline void UpdateRootNodeTransformValues( Layer& rootNode, int nodeDirtyFlags, BufferIndex updateBufferIndex ) -{ - // If the transform values need to be reinherited - if ( nodeDirtyFlags & TransformFlag ) - { - rootNode.SetWorldPosition( updateBufferIndex, rootNode.GetPosition( updateBufferIndex ) ); - rootNode.SetWorldOrientation( updateBufferIndex, rootNode.GetOrientation( updateBufferIndex ) ); - rootNode.SetWorldScale ( updateBufferIndex, rootNode.GetScale ( updateBufferIndex ) ); - } - else - { - // Copy previous value, in case they changed in the previous frame - rootNode.CopyPreviousWorldOrientation( updateBufferIndex ); - rootNode.CopyPreviousWorldScale( updateBufferIndex ); - rootNode.CopyPreviousWorldPosition( updateBufferIndex ); + node.CopyPreviousWorldColor(updateBufferIndex); } } /** - * Updates transform values for the given node if the transform flag is dirty. - * Note that this will cause the size dirty flag to be set. This is why we pass - * the dirty flags in by reference. - * @param[in] node The node to update - * @param[in,out] nodeDirtyFlags A reference to the dirty flags, these may be modified by this function - * @param[in] updateBufferIndex The current index to use for this frame + * This is called recursively for all children of the root Node */ -inline void UpdateNodeTransformValues( Node& node, int& nodeDirtyFlags, BufferIndex updateBufferIndex ) +inline NodePropertyFlags UpdateNodes(Node& node, + NodePropertyFlags parentFlags, + BufferIndex updateBufferIndex, + RenderQueue& renderQueue, + bool updated) { - // If the transform values need to be reinherited - if( nodeDirtyFlags & TransformFlag ) - { - // With a non-central anchor-point, the world rotation and scale affects the world position. - // Therefore the world rotation & scale must be updated before the world position. - if( node.IsOrientationInherited() ) - { - node.InheritWorldOrientation( updateBufferIndex ); - } - else - { - node.SetWorldOrientation( updateBufferIndex, node.GetOrientation( updateBufferIndex ) ); - } + // Apply constraints to the node + ConstrainPropertyOwner(node, updateBufferIndex); - if( node.IsScaleInherited() ) - { - node.InheritWorldScale( updateBufferIndex ); - } - else - { - node.SetWorldScale( updateBufferIndex, node.GetScale( updateBufferIndex ) ); - } + // Some dirty flags are inherited from parent + NodePropertyFlags nodeDirtyFlags = node.GetDirtyFlags() | node.GetInheritedDirtyFlags(parentFlags); - node.InheritWorldPosition( updateBufferIndex ); - } - else - { - // Copy inherited values, if those changed in the previous frame - node.CopyPreviousWorldOrientation( updateBufferIndex ); - node.CopyPreviousWorldScale( updateBufferIndex ); - node.CopyPreviousWorldPosition( updateBufferIndex ); - node.CopyPreviousSize( updateBufferIndex ); - } -} + NodePropertyFlags cumulativeDirtyFlags = nodeDirtyFlags; -inline void UpdateNodeWorldMatrix( Node &node, int nodeDirtyFlags, BufferIndex updateBufferIndex ) -{ - // If world-matrix needs to be recalculated - if ( nodeDirtyFlags & TransformFlag ) - { - if( node.GetInhibitLocalTransform() ) - { - node.SetWorldMatrix( updateBufferIndex, - node.GetWorldScale(updateBufferIndex), - node.GetWorldOrientation(updateBufferIndex) / node.GetOrientation(updateBufferIndex), - node.GetWorldPosition(updateBufferIndex) - node.GetPosition(updateBufferIndex) ); - } - else - { - node.SetWorldMatrix( updateBufferIndex, - node.GetWorldScale(updateBufferIndex), - node.GetWorldOrientation(updateBufferIndex), - node.GetWorldPosition(updateBufferIndex) ); - } - } - else - { - node.CopyPreviousWorldMatrix( updateBufferIndex ); - } -} + UpdateNodeOpacity(node, nodeDirtyFlags, updateBufferIndex); -inline void UpdateNodeWorldMatrix( Node& node, RenderableAttachment& updatedRenderable, int nodeDirtyFlags, BufferIndex updateBufferIndex ) -{ - /** - * If world-matrix needs to be recalculated. - */ - if ( ( nodeDirtyFlags & TransformFlag ) || - updatedRenderable.IsScaleForSizeDirty() ) + node.UpdateUniformHash(updateBufferIndex); + + // For partial update, mark all children of an animating node as updated. + if(updated) // Only set to updated if parent was updated. { - if( updatedRenderable.UsesGeometryScaling() ) - { - // TODO: MESH_REWORK : remove scale for size - Vector3 scaling; - updatedRenderable.GetScaleForSize( node.GetSize( updateBufferIndex ), scaling ); - if( node.GetInhibitLocalTransform() ) - { - node.SetWorldMatrix( updateBufferIndex, - node.GetWorldScale(updateBufferIndex) * scaling, - node.GetWorldOrientation(updateBufferIndex) / node.GetOrientation(updateBufferIndex), - node.GetWorldPosition(updateBufferIndex) - node.GetPosition(updateBufferIndex) ); - } - else - { - node.SetWorldMatrix( updateBufferIndex, - node.GetWorldScale(updateBufferIndex) * scaling, - node.GetWorldOrientation(updateBufferIndex), - node.GetWorldPosition(updateBufferIndex) ); - } - } - else - { - // no scaling, i.e. Image - if( node.GetInhibitLocalTransform() ) - { - node.SetWorldMatrix( updateBufferIndex, - node.GetWorldScale(updateBufferIndex), - node.GetWorldOrientation(updateBufferIndex) / node.GetOrientation(updateBufferIndex), - node.GetWorldPosition(updateBufferIndex) - node.GetPosition(updateBufferIndex) ); - } - else - { - node.SetWorldMatrix( updateBufferIndex, - node.GetWorldScale(updateBufferIndex), - node.GetWorldOrientation(updateBufferIndex), - node.GetWorldPosition(updateBufferIndex) ); - } - } + node.SetUpdated(true); } - else + else if(node.Updated()) // Only propagate updated==true downwards. { - node.CopyPreviousWorldMatrix( updateBufferIndex ); + updated = true; } -} - -/** - * Update an attachment. - * @return An updated renderable attachment if one was ready. - */ -inline RenderableAttachment* UpdateAttachment( NodeAttachment& attachment, - Node& node, - BufferIndex updateBufferIndex, - ResourceManager& resourceManager, - int nodeDirtyFlags ) -{ - // Allow attachments to do specialised processing during updates - attachment.Update( updateBufferIndex, node, nodeDirtyFlags ); - RenderableAttachment* renderable = attachment.GetRenderable(); // not all scene objects render - if( renderable ) + // recurse children + NodeContainer& children = node.GetChildren(); + const NodeIter endIter = children.End(); + for(NodeIter iter = children.Begin(); iter != endIter; ++iter) { - // Notify renderables when size has changed - // Size can change while node was invisible so we need to check size again if we were previously invisible - if( nodeDirtyFlags & (SizeFlag|VisibleFlag) ) - { - renderable->SizeChanged( updateBufferIndex ); - } - - // check if node is visible - if( renderable->ResolveVisibility( updateBufferIndex ) ) - { - renderable->PrepareResources( updateBufferIndex, resourceManager ); - } + Node& child = **iter; + cumulativeDirtyFlags |= UpdateNodes(child, + nodeDirtyFlags, + updateBufferIndex, + renderQueue, + updated); } - return renderable; -} -inline void AddRenderableToLayer( Layer& layer, - RenderableAttachment& renderable, - BufferIndex updateBufferIndex, - int inheritedDrawMode ) -{ - // The renderables are stored into the opaque list temporarily for PrepareRenderables() - // step. The list is cleared by ProcessRenderTasks(). - layer.opaqueRenderables.push_back( &renderable ); + return cumulativeDirtyFlags; } /** - * This is called recursively for all children of the root Node + * The root node is treated separately; it cannot inherit values since it has no parent */ -inline int UpdateNodesAndAttachments( Node& node, - int parentFlags, - BufferIndex updateBufferIndex, - ResourceManager& resourceManager, - RenderQueue& renderQueue, - Layer& currentLayer, - int inheritedDrawMode ) +NodePropertyFlags UpdateNodeTree(Layer& rootNode, + BufferIndex updateBufferIndex, + RenderQueue& renderQueue) { - Layer* layer = ¤tLayer; + DALI_ASSERT_DEBUG(rootNode.IsRoot()); // Short-circuit for invisible nodes - if ( !node.IsVisible( updateBufferIndex ) ) + if(DALI_UNLIKELY(!rootNode.IsVisible(updateBufferIndex))) // almost never ever true { - return 0; + return NodePropertyFlags::NOTHING; } - // If the node was not previously visible + // If the root node was not previously visible BufferIndex previousBuffer = updateBufferIndex ? 0u : 1u; - if ( !node.IsVisible( previousBuffer ) ) + if(DALI_UNLIKELY(!rootNode.IsVisible(previousBuffer))) // almost never ever true { // The node was skipped in the previous update; it must recalculate everything - node.SetAllDirtyFlags(); + rootNode.SetAllDirtyFlags(); } - // Some dirty flags are inherited from parent - int nodeDirtyFlags( node.GetDirtyFlags() | ( parentFlags & InheritedDirtyFlags ) ); - - int cumulativeDirtyFlags = nodeDirtyFlags; - - if ( node.IsLayer() ) - { - // all childs go to this layer - layer = node.GetLayer(); - - // assume layer is clean to begin with - layer->SetReuseRenderers( updateBufferIndex, true ); + NodePropertyFlags nodeDirtyFlags(rootNode.GetDirtyFlags()); - // Layers do not inherit the DrawMode from their parents - inheritedDrawMode = DrawMode::NORMAL; - } - DALI_ASSERT_DEBUG( NULL != layer ); + NodePropertyFlags cumulativeDirtyFlags = nodeDirtyFlags; - UpdateNodeOpacity( node, nodeDirtyFlags, updateBufferIndex ); + UpdateRootNodeOpacity(rootNode, nodeDirtyFlags, updateBufferIndex); - // Note: nodeDirtyFlags are passed in by reference and may be modified by the following function. - // It is important that the modified version of these flags are used by the RenderableAttachment. - UpdateNodeTransformValues( node, nodeDirtyFlags, updateBufferIndex ); + bool updated = rootNode.Updated(); - // Setting STENCIL will override OVERLAY, if that would otherwise have been inherited. - inheritedDrawMode |= node.GetDrawMode(); - - if ( node.HasAttachment() ) + // recurse children + NodeContainer& children = rootNode.GetChildren(); + const NodeIter endIter = children.End(); + for(NodeIter iter = children.Begin(); iter != endIter; ++iter) { - /* - * Add renderables for the children into the current Layer - */ - RenderableAttachment* renderable = UpdateAttachment( node.GetAttachment(), - node, - updateBufferIndex, - resourceManager, - nodeDirtyFlags ); + Node& child = **iter; + cumulativeDirtyFlags |= UpdateNodes(child, + nodeDirtyFlags, + updateBufferIndex, + renderQueue, + updated); + } + return cumulativeDirtyFlags; +} - if( NULL != renderable ) - { - // Update the world matrix after renderable update; the ScaleForSize property should now be calculated - UpdateNodeWorldMatrix( node, *renderable, nodeDirtyFlags, updateBufferIndex ); +inline void UpdateLayers(Node& node, + NodePropertyFlags parentFlags, + BufferIndex updateBufferIndex, + Layer& currentLayer) +{ + // Some dirty flags are inherited from parent + NodePropertyFlags nodeDirtyFlags = node.GetDirtyFlags() | node.GetInheritedDirtyFlags(parentFlags); + nodeDirtyFlags |= (node.IsLocalMatrixDirty() ? NodePropertyFlags::TRANSFORM : NodePropertyFlags::NOTHING); - // The attachment is ready to render, so it is added to a set of renderables. - AddRenderableToLayer( *layer, *renderable, updateBufferIndex, inheritedDrawMode ); - } - } - else if( node.IsObserved() ) + Layer* nodeIsLayer(node.GetLayer()); + Layer* layer = nodeIsLayer ? nodeIsLayer : ¤tLayer; + if(nodeIsLayer) { - // This node is being used as a property input for an animation, constraint, - // camera or bone. Ensure it's matrix is updated - UpdateNodeWorldMatrix( node, nodeDirtyFlags, updateBufferIndex ); + layer->SetReuseRenderers(updateBufferIndex, true); } + DALI_ASSERT_DEBUG(nullptr != layer); // if any child node has moved or had its sort modifier changed, layer is not clean and old frame cannot be reused // also if node has been deleted, dont reuse old render items - if( nodeDirtyFlags & RenderableUpdateFlags ) + if(nodeDirtyFlags != NodePropertyFlags::NOTHING) + { + layer->SetReuseRenderers(updateBufferIndex, false); + } + else { - layer->SetReuseRenderers( updateBufferIndex, false ); + // If the node is not dirty, then check renderers + const uint32_t count = node.GetRendererCount(); + for(uint32_t i = 0; i < count; ++i) + { + SceneGraph::Renderer* renderer = node.GetRendererAt(i); + if(renderer->IsDirty()) + { + layer->SetReuseRenderers(updateBufferIndex, false); + break; + } + } } // recurse children NodeContainer& children = node.GetChildren(); - const NodeIter endIter = children.End(); - for ( NodeIter iter = children.Begin(); iter != endIter; ++iter ) + const NodeIter endIter = children.End(); + for(NodeIter iter = children.Begin(); iter != endIter; ++iter) { Node& child = **iter; - cumulativeDirtyFlags |=UpdateNodesAndAttachments( child, - nodeDirtyFlags, - updateBufferIndex, - resourceManager, - renderQueue, - *layer, - inheritedDrawMode ); + UpdateLayers(child, nodeDirtyFlags, updateBufferIndex, *layer); } - - return cumulativeDirtyFlags; } -/** - * The root node is treated separately; it cannot inherit values since it has no parent - */ -int UpdateNodesAndAttachments( Layer& rootNode, - BufferIndex updateBufferIndex, - ResourceManager& resourceManager, - RenderQueue& renderQueue ) +void UpdateLayerTree(Layer& layer, + BufferIndex updateBufferIndex) { - DALI_ASSERT_DEBUG( rootNode.IsRoot() ); + NodePropertyFlags nodeDirtyFlags = layer.GetDirtyFlags(); + nodeDirtyFlags |= (layer.IsLocalMatrixDirty() ? NodePropertyFlags::TRANSFORM : NodePropertyFlags::NOTHING); - // Short-circuit for invisible nodes - if ( !rootNode.IsVisible( updateBufferIndex ) ) - { - return 0; - } - - // If the root node was not previously visible - BufferIndex previousBuffer = updateBufferIndex ? 0u : 1u; - if ( !rootNode.IsVisible( previousBuffer ) ) - { - // The node was skipped in the previous update; it must recalculate everything - rootNode.SetAllDirtyFlags(); - } - - int nodeDirtyFlags( rootNode.GetDirtyFlags() ); - - int cumulativeDirtyFlags = nodeDirtyFlags; - - UpdateRootNodeOpacity( rootNode, nodeDirtyFlags, updateBufferIndex ); - - UpdateRootNodeTransformValues( rootNode, nodeDirtyFlags, updateBufferIndex ); - - DrawMode::Type drawMode( rootNode.GetDrawMode() ); + layer.SetReuseRenderers(updateBufferIndex, nodeDirtyFlags == NodePropertyFlags::NOTHING); // recurse children - NodeContainer& children = rootNode.GetChildren(); - const NodeIter endIter = children.End(); - for ( NodeIter iter = children.Begin(); iter != endIter; ++iter ) + NodeContainer& children = layer.GetChildren(); + const NodeIter endIter = children.End(); + for(NodeIter iter = children.Begin(); iter != endIter; ++iter) { Node& child = **iter; - cumulativeDirtyFlags |= UpdateNodesAndAttachments( child, - nodeDirtyFlags, - updateBufferIndex, - resourceManager, - renderQueue, - rootNode, - drawMode ); + UpdateLayers(child, nodeDirtyFlags, updateBufferIndex, layer); } - - return cumulativeDirtyFlags; } } // namespace SceneGraph