X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fupdate%2Fmanager%2Fupdate-algorithms.cpp;h=b767b581ad8db99093429198c190ad831e787fc8;hb=ba40f528f8ca9ba401a364c37599f0774e9ee821;hp=6a2d8ed6636e404af8ffba9f2f8ef96d53a55bd4;hpb=9d825be196fa6565a6dabc8647fe4867f5e9a89a;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..b767b58 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) 2018 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. @@ -25,13 +25,10 @@ #include #include #include -#include #include -#include -#include #include #include -#include +#include #include @@ -57,7 +54,6 @@ Debug::Filter* gUpdateFilter = Debug::Filter::New(Debug::Concise, false, "LOG_UP * 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 ) { @@ -71,49 +67,13 @@ void ConstrainPropertyOwner( PropertyOwner& propertyOwner, BufferIndex updateBuf } } -/** - * 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 ); - } -} - /****************************************************************************** ************************** 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 ); } @@ -124,10 +84,10 @@ inline void UpdateRootNodeOpacity( Layer& rootNode, int nodeDirtyFlags, BufferIn } } -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 ); } @@ -138,207 +98,23 @@ inline void UpdateNodeOpacity( Node& node, int nodeDirtyFlags, BufferIndex updat } } -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 ); - } -} - -/** - * 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 - */ -inline void UpdateNodeTransformValues( Node& node, int& nodeDirtyFlags, BufferIndex updateBufferIndex ) -{ - // 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 ) ); - } - - if( node.IsScaleInherited() ) - { - node.InheritWorldScale( updateBufferIndex ); - } - else - { - node.SetWorldScale( updateBufferIndex, node.GetScale( updateBufferIndex ) ); - } - - 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 ); - } -} - -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 ); - } -} - -inline void UpdateNodeWorldMatrix( Node& node, RenderableAttachment& updatedRenderable, int nodeDirtyFlags, BufferIndex updateBufferIndex ) -{ - /** - * If world-matrix needs to be recalculated. - */ - if ( ( nodeDirtyFlags & TransformFlag ) || - updatedRenderable.IsScaleForSizeDirty() ) - { - 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) ); - } - } - } - else - { - node.CopyPreviousWorldMatrix( updateBufferIndex ); - } -} - -/** - * 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 ) - { - // 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 ); - } - } - 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 ); -} - /** * This is called recursively for all children of the root Node */ -inline int UpdateNodesAndAttachments( Node& node, - int parentFlags, +inline NodePropertyFlags UpdateNodes( Node& node, + NodePropertyFlags parentFlags, BufferIndex updateBufferIndex, - ResourceManager& resourceManager, RenderQueue& renderQueue, Layer& currentLayer, - int inheritedDrawMode ) + uint32_t inheritedDrawMode ) { - Layer* layer = ¤tLayer; + // Apply constraints to the node + ConstrainPropertyOwner( node, updateBufferIndex ); // Short-circuit for invisible nodes if ( !node.IsVisible( updateBufferIndex ) ) { - return 0; + return NodePropertyFlags::NOTHING; } // If the node was not previously visible @@ -350,14 +126,16 @@ inline int UpdateNodesAndAttachments( Node& node, } // Some dirty flags are inherited from parent - int nodeDirtyFlags( node.GetDirtyFlags() | ( parentFlags & InheritedDirtyFlags ) ); + NodePropertyFlags nodeDirtyFlags = node.GetInheritedDirtyFlags( parentFlags ); - int cumulativeDirtyFlags = nodeDirtyFlags; + NodePropertyFlags cumulativeDirtyFlags = nodeDirtyFlags; - if ( node.IsLayer() ) + Layer* layer = ¤tLayer; + Layer* nodeIsLayer( node.GetLayer() ); + if( nodeIsLayer ) { // all childs go to this layer - layer = node.GetLayer(); + layer = nodeIsLayer; // assume layer is clean to begin with layer->SetReuseRenderers( updateBufferIndex, true ); @@ -369,40 +147,10 @@ inline int UpdateNodesAndAttachments( Node& node, UpdateNodeOpacity( node, 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 ); - - // Setting STENCIL will override OVERLAY, if that would otherwise have been inherited. + // Draw mode inheritance is treated as or-ing the modes together (as they are a bit-mask). inheritedDrawMode |= node.GetDrawMode(); - if ( node.HasAttachment() ) - { - /* - * Add renderables for the children into the current Layer - */ - RenderableAttachment* renderable = UpdateAttachment( node.GetAttachment(), - node, - updateBufferIndex, - resourceManager, - nodeDirtyFlags ); - - - if( NULL != renderable ) - { - // Update the world matrix after renderable update; the ScaleForSize property should now be calculated - UpdateNodeWorldMatrix( node, *renderable, nodeDirtyFlags, updateBufferIndex ); - - // The attachment is ready to render, so it is added to a set of renderables. - AddRenderableToLayer( *layer, *renderable, updateBufferIndex, inheritedDrawMode ); - } - } - else if( node.IsObserved() ) - { - // 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 ); - } + 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 @@ -417,13 +165,12 @@ inline int UpdateNodesAndAttachments( Node& node, for ( NodeIter iter = children.Begin(); iter != endIter; ++iter ) { Node& child = **iter; - cumulativeDirtyFlags |=UpdateNodesAndAttachments( child, - nodeDirtyFlags, - updateBufferIndex, - resourceManager, - renderQueue, - *layer, - inheritedDrawMode ); + cumulativeDirtyFlags |=UpdateNodes( child, + nodeDirtyFlags, + updateBufferIndex, + renderQueue, + *layer, + inheritedDrawMode ); } return cumulativeDirtyFlags; @@ -432,35 +179,32 @@ inline int UpdateNodesAndAttachments( Node& node, /** * 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 ) +NodePropertyFlags UpdateNodeTree( Layer& rootNode, + BufferIndex updateBufferIndex, + RenderQueue& renderQueue ) { DALI_ASSERT_DEBUG( rootNode.IsRoot() ); // Short-circuit for invisible nodes - if ( !rootNode.IsVisible( updateBufferIndex ) ) + 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 ( !rootNode.IsVisible( previousBuffer ) ) + 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 ); - UpdateRootNodeTransformValues( rootNode, nodeDirtyFlags, updateBufferIndex ); - DrawMode::Type drawMode( rootNode.GetDrawMode() ); // recurse children @@ -469,13 +213,12 @@ int UpdateNodesAndAttachments( Layer& rootNode, for ( NodeIter iter = children.Begin(); iter != endIter; ++iter ) { Node& child = **iter; - cumulativeDirtyFlags |= UpdateNodesAndAttachments( child, - nodeDirtyFlags, - updateBufferIndex, - resourceManager, - renderQueue, - rootNode, - drawMode ); + cumulativeDirtyFlags |= UpdateNodes( child, + nodeDirtyFlags, + updateBufferIndex, + renderQueue, + rootNode, + drawMode ); } return cumulativeDirtyFlags;