X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fupdate%2Fmanager%2Fupdate-algorithms.cpp;h=7cd6ac6beac227c4a00e234d70d0ee2c4d1c7c69;hb=5de727a5d6b9ef995c93eff4d4e47a086784a332;hp=d7f9759b0174cc8cdd54f2903b84133a5afde049;hpb=03bb1840a40c61ff70f4de174615d93240bca7d8;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 d7f9759..7cd6ac6 100644 --- a/dali/internal/update/manager/update-algorithms.cpp +++ b/dali/internal/update/manager/update-algorithms.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016 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,25 +22,22 @@ #include // INTERNAL INCLUDES +#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 @@ -49,22 +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 ); + constraint.Apply(updateBufferIndex); } } @@ -72,106 +67,75 @@ void ConstrainPropertyOwner( PropertyOwner& propertyOwner, BufferIndex updateBuf ************************** 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 ); + node.CopyPreviousWorldColor(updateBufferIndex); } } /** * This is called recursively for all children of the root Node */ -inline int UpdateNodes( Node& node, - int parentFlags, - BufferIndex updateBufferIndex, - RenderQueue& renderQueue, - Layer& currentLayer, - int inheritedDrawMode ) +inline NodePropertyFlags UpdateNodes(Node& node, + NodePropertyFlags parentFlags, + BufferIndex updateBufferIndex, + RenderQueue& renderQueue, + bool updated) { - //Apply constraints to the node - ConstrainPropertyOwner( node, updateBufferIndex ); - - // Short-circuit for invisible nodes - if ( !node.IsVisible( updateBufferIndex ) ) - { - return 0; - } - - // If the node was not previously visible - BufferIndex previousBuffer = updateBufferIndex ? 0u : 1u; - if ( !node.IsVisible( previousBuffer ) ) - { - // The node was skipped in the previous update; it must recalculate everything - node.SetAllDirtyFlags(); - } + // Apply constraints to the node + ConstrainPropertyOwner(node, updateBufferIndex); // Some dirty flags are inherited from parent - int nodeDirtyFlags( node.GetDirtyFlags() | ( parentFlags & InheritedDirtyFlags ) ); + NodePropertyFlags nodeDirtyFlags = node.GetDirtyFlags() | node.GetInheritedDirtyFlags(parentFlags); - int cumulativeDirtyFlags = nodeDirtyFlags; + NodePropertyFlags cumulativeDirtyFlags = nodeDirtyFlags; - Layer* layer = ¤tLayer; - Layer* nodeIsLayer( node.GetLayer() ); - if( nodeIsLayer ) - { - // all childs go to this layer - layer = nodeIsLayer; + UpdateNodeOpacity(node, nodeDirtyFlags, updateBufferIndex); - // assume layer is clean to begin with - layer->SetReuseRenderers( updateBufferIndex, true ); + node.UpdateUniformHash(updateBufferIndex); - // Layers do not inherit the DrawMode from their parents - inheritedDrawMode = DrawMode::NORMAL; + // For partial update, mark all children of an animating node as updated. + if(updated) // Only set to updated if parent was updated. + { + node.SetUpdated(true); } - DALI_ASSERT_DEBUG( NULL != layer ); - - UpdateNodeOpacity( node, nodeDirtyFlags, updateBufferIndex ); - - // Draw mode inheritance is treated as or-ing the modes together (as they are a bit-mask). - inheritedDrawMode |= node.GetDrawMode(); - - node.PrepareRender( updateBufferIndex ); - - // 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 ) + else if(node.Updated()) // Only propagate updated==true downwards. { - layer->SetReuseRenderers( updateBufferIndex, false ); + updated = true; } // 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 |=UpdateNodes( child, + cumulativeDirtyFlags |= UpdateNodes(child, nodeDirtyFlags, updateBufferIndex, renderQueue, - *layer, - inheritedDrawMode ); + updated); } return cumulativeDirtyFlags; @@ -180,51 +144,116 @@ inline int UpdateNodes( Node& node, /** * The root node is treated separately; it cannot inherit values since it has no parent */ -int UpdateNodeTree( Layer& rootNode, - BufferIndex updateBufferIndex, - RenderQueue& renderQueue ) +NodePropertyFlags UpdateNodeTree(Layer& rootNode, + BufferIndex updateBufferIndex, + RenderQueue& renderQueue) { - DALI_ASSERT_DEBUG( rootNode.IsRoot() ); + DALI_ASSERT_DEBUG(rootNode.IsRoot()); // Short-circuit for invisible nodes - if ( DALI_UNLIKELY( !rootNode.IsVisible( updateBufferIndex ) ) ) // almost never ever true + if(DALI_UNLIKELY(!rootNode.IsVisible(updateBufferIndex))) // almost never ever true { - return 0; + return NodePropertyFlags::NOTHING; } // If the root node was not previously visible BufferIndex previousBuffer = updateBufferIndex ? 0u : 1u; - if ( DALI_UNLIKELY( !rootNode.IsVisible( previousBuffer ) ) ) // almost never ever true + if(DALI_UNLIKELY(!rootNode.IsVisible(previousBuffer))) // almost never ever true { // The node was skipped in the previous update; it must recalculate everything rootNode.SetAllDirtyFlags(); } - int nodeDirtyFlags( rootNode.GetDirtyFlags() ); + NodePropertyFlags nodeDirtyFlags(rootNode.GetDirtyFlags()); - int cumulativeDirtyFlags = nodeDirtyFlags; + NodePropertyFlags cumulativeDirtyFlags = nodeDirtyFlags; - UpdateRootNodeOpacity( rootNode, nodeDirtyFlags, updateBufferIndex ); + UpdateRootNodeOpacity(rootNode, nodeDirtyFlags, updateBufferIndex); - DrawMode::Type drawMode( rootNode.GetDrawMode() ); + bool updated = rootNode.Updated(); // recurse children NodeContainer& children = rootNode.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 |= UpdateNodes( child, - nodeDirtyFlags, - updateBufferIndex, - renderQueue, - rootNode, - drawMode ); + cumulativeDirtyFlags |= UpdateNodes(child, + nodeDirtyFlags, + updateBufferIndex, + renderQueue, + updated); } return cumulativeDirtyFlags; } +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); + + Layer* nodeIsLayer(node.GetLayer()); + Layer* layer = nodeIsLayer ? nodeIsLayer : ¤tLayer; + if(nodeIsLayer) + { + 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 != NodePropertyFlags::NOTHING) + { + layer->SetReuseRenderers(updateBufferIndex, false); + } + else + { + // 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) + { + Node& child = **iter; + UpdateLayers(child, nodeDirtyFlags, updateBufferIndex, *layer); + } +} + +void UpdateLayerTree(Layer& layer, + BufferIndex updateBufferIndex) +{ + NodePropertyFlags nodeDirtyFlags = layer.GetDirtyFlags(); + nodeDirtyFlags |= (layer.IsLocalMatrixDirty() ? NodePropertyFlags::TRANSFORM : NodePropertyFlags::NOTHING); + + layer.SetReuseRenderers(updateBufferIndex, nodeDirtyFlags == NodePropertyFlags::NOTHING); + + // recurse children + NodeContainer& children = layer.GetChildren(); + const NodeIter endIter = children.End(); + for(NodeIter iter = children.Begin(); iter != endIter; ++iter) + { + Node& child = **iter; + UpdateLayers(child, nodeDirtyFlags, updateBufferIndex, layer); + } +} + } // namespace SceneGraph } // namespace Internal