X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fupdate%2Fmanager%2Frender-instruction-processor.cpp;h=cd7ccb20bdd62ef468259ab71264006c543bc30f;hb=db19f62c335177ef99817f74481df996d2044b98;hp=0592ad92c74e0097102695a9eb6d8c61e5751bed;hpb=41005e5e50f465c769b0cce885ac9b52af1420b2;p=platform%2Fcore%2Fuifw%2Fdali-core.git diff --git a/dali/internal/update/manager/render-instruction-processor.cpp b/dali/internal/update/manager/render-instruction-processor.cpp index 0592ad9..cd7ccb2 100644 --- a/dali/internal/update/manager/render-instruction-processor.cpp +++ b/dali/internal/update/manager/render-instruction-processor.cpp @@ -20,6 +20,7 @@ // INTERNAL INCLUDES #include +#include #include // for the default sorting function #include #include @@ -137,34 +138,34 @@ bool CompareItems3DWithClipping(const RenderInstructionProcessor::SortAttributes } /** - * Set the update size of the node + * Set the update area of the node * @param[in] node The node of the renderer * @param[in] isLayer3d Whether we are processing a 3D layer or not * @param[in,out] nodeWorldMatrix The world matrix of the node * @param[in,out] nodeSize The size of the node - * @param[in,out] nodeUpdateSize The update size of the node + * @param[in,out] nodeUpdateArea The update area of the node * - * @return True if node use it's own UpdateSizeHint, or z transform occured. False if we use nodeUpdateSize equal with nodeSize. + * @return True if node use it's own UpdateAreaHint, or z transform occured. False if we use nodeUpdateArea equal with Vector4(0, 0, nodeSize.width, nodeSize.height). */ -inline bool SetNodeUpdateSize(Node* node, bool isLayer3d, Matrix& nodeWorldMatrix, Vector3& nodeSize, Vector3& nodeUpdateSize) +inline bool SetNodeUpdateArea(Node* node, bool isLayer3d, Matrix& nodeWorldMatrix, Vector3& nodeSize, Vector4& nodeUpdateArea) { node->GetWorldMatrixAndSize(nodeWorldMatrix, nodeSize); - if(node->GetUpdateSizeHint() == Vector3::ZERO) + if(node->GetUpdateAreaHint() == Vector4::ZERO) { // RenderItem::CalculateViewportSpaceAABB cannot cope with z transform // I don't use item.mModelMatrix.GetTransformComponents() for z transform, would be too slow if(!isLayer3d && nodeWorldMatrix.GetZAxis() == Vector3(0.0f, 0.0f, 1.0f)) { - nodeUpdateSize = nodeSize; + nodeUpdateArea = Vector4(0.0f, 0.0f, nodeSize.width, nodeSize.height); return false; } - // Keep nodeUpdateSize as Vector3::ZERO, and return true. + // Keep nodeUpdateArea as Vector4::ZERO, and return true. return true; } else { - nodeUpdateSize = node->GetUpdateSizeHint(); + nodeUpdateArea = node->GetUpdateAreaHint(); return true; } } @@ -181,23 +182,23 @@ inline bool SetNodeUpdateSize(Node* node, bool isLayer3d, Matrix& nodeWorldMatri * @param viewport The viewport * @param cull Whether frustum culling is enabled or not */ -inline void AddRendererToRenderList(BufferIndex updateBufferIndex, - RenderList& renderList, - Renderable& renderable, - const Matrix& viewMatrix, - SceneGraph::Camera& camera, - bool isLayer3d, - bool viewportSet, - const Viewport& viewport, - bool cull) +inline void AddRendererToRenderList(BufferIndex updateBufferIndex, + RenderList& renderList, + Renderable& renderable, + const Matrix& viewMatrix, + const SceneGraph::Camera& camera, + bool isLayer3d, + bool viewportSet, + const Viewport& viewport, + bool cull) { bool inside(true); Node* node = renderable.mNode; Matrix nodeWorldMatrix(false); Vector3 nodeSize; - Vector3 nodeUpdateSize; - bool nodeUpdateSizeSet(false); - bool nodeUpdateSizeUseHint(false); + Vector4 nodeUpdateArea; + bool nodeUpdateAreaSet(false); + bool nodeUpdateAreaUseHint(false); Matrix nodeModelViewMatrix(false); bool nodeModelViewMatrixSet(false); @@ -212,21 +213,21 @@ inline void AddRendererToRenderList(BufferIndex updateBufferIndex, if(inside && !isLayer3d && viewportSet) { - nodeUpdateSizeUseHint = SetNodeUpdateSize(node, isLayer3d, nodeWorldMatrix, nodeSize, nodeUpdateSize); - nodeUpdateSizeSet = true; + nodeUpdateAreaUseHint = SetNodeUpdateArea(node, isLayer3d, nodeWorldMatrix, nodeSize, nodeUpdateArea); + nodeUpdateAreaSet = true; const Vector3& scale = node->GetWorldScale(updateBufferIndex); - const Vector3& size = nodeUpdateSize * scale; + const Vector3& size = Vector3(nodeUpdateArea.z, nodeUpdateArea.w, 1.0f) * scale; if(size.LengthSquared() > Math::MACHINE_EPSILON_1000) { - Matrix::Multiply(nodeModelViewMatrix, nodeWorldMatrix, viewMatrix); + MatrixUtils::Multiply(nodeModelViewMatrix, nodeWorldMatrix, viewMatrix); nodeModelViewMatrixSet = true; // Assume actors are at z=0, compute AABB in view space & test rect intersection // against z=0 plane boundaries for frustum. (NOT viewport). This should take into account // magnification due to FOV etc. - ClippingBox boundingBox = RenderItem::CalculateTransformSpaceAABB(nodeModelViewMatrix, nodeUpdateSize); + ClippingBox boundingBox = RenderItem::CalculateTransformSpaceAABB(nodeModelViewMatrix, Vector3(nodeUpdateArea.x, nodeUpdateArea.y, 0.0f), Vector3(nodeUpdateArea.z, nodeUpdateArea.w, 0.0f)); ClippingBox clippingBox(camera.mLeftClippingPlane, camera.mBottomClippingPlane, camera.mRightClippingPlane - camera.mLeftClippingPlane, fabsf(camera.mBottomClippingPlane - camera.mTopClippingPlane)); inside = clippingBox.Intersects(boundingBox); } @@ -268,6 +269,7 @@ inline void AddRendererToRenderList(BufferIndex updateBufferIndex, if(DALI_LIKELY(renderable.mRenderer)) { + partialRenderingCacheInfo.color.a *= renderable.mRenderer->GetOpacity(updateBufferIndex); partialRenderingCacheInfo.textureSet = renderable.mRenderer->GetTextureSet(); } @@ -287,8 +289,8 @@ inline void AddRendererToRenderList(BufferIndex updateBufferIndex, item.mTextureSet = renderable.mRenderer->GetTextureSet(); item.mDepthIndex += renderable.mRenderer->GetDepthIndex(); - // Ensure collected map is up to date - item.mIsUpdated |= renderable.mRenderer->UpdateUniformMap(); + // Get whether collected map is up to date + item.mIsUpdated |= renderable.mRenderer->UniformMapUpdated(); } else { @@ -297,30 +299,32 @@ inline void AddRendererToRenderList(BufferIndex updateBufferIndex, item.mIsUpdated |= isLayer3d; - if(!nodeUpdateSizeSet) + if(!nodeUpdateAreaSet) { - nodeUpdateSizeUseHint = SetNodeUpdateSize(node, isLayer3d, nodeWorldMatrix, nodeSize, nodeUpdateSize); + nodeUpdateAreaUseHint = SetNodeUpdateArea(node, isLayer3d, nodeWorldMatrix, nodeSize, nodeUpdateArea); } item.mSize = nodeSize; - item.mUpdateSize = nodeUpdateSize; + item.mUpdateArea = nodeUpdateArea; item.mModelMatrix = nodeWorldMatrix; // Apply transform informations if node doesn't have update size hint and use VisualRenderer. - if(!nodeUpdateSizeUseHint && renderable.mRenderer && renderable.mRenderer->GetVisualProperties()) + if(!nodeUpdateAreaUseHint && renderable.mRenderer && renderable.mRenderer->GetVisualProperties()) { - item.mUpdateSize = renderable.mRenderer->CalculateVisualTransformedUpdateSize(updateBufferIndex, item.mUpdateSize); + Vector3 updateSize = renderable.mRenderer->CalculateVisualTransformedUpdateSize(updateBufferIndex, Vector3(item.mUpdateArea.z, item.mUpdateArea.w, 0.0f)); + item.mUpdateArea.z = updateSize.x; + item.mUpdateArea.w = updateSize.y; } if(!nodeModelViewMatrixSet) { - Matrix::Multiply(nodeModelViewMatrix, nodeWorldMatrix, viewMatrix); + MatrixUtils::Multiply(nodeModelViewMatrix, nodeWorldMatrix, viewMatrix); } item.mModelViewMatrix = nodeModelViewMatrix; - partialRenderingCacheInfo.matrix = item.mModelViewMatrix; - partialRenderingCacheInfo.size = item.mSize; - partialRenderingCacheInfo.updatedSize = item.mUpdateSize; + partialRenderingCacheInfo.matrix = item.mModelViewMatrix; + partialRenderingCacheInfo.size = item.mSize; + partialRenderingCacheInfo.updatedPositionSize = item.mUpdateArea; item.mIsUpdated = partialRenderingData.IsUpdated() || item.mIsUpdated; @@ -358,15 +362,15 @@ inline void AddRendererToRenderList(BufferIndex updateBufferIndex, * @param isLayer3d Whether we are processing a 3D layer or not * @param cull Whether frustum culling is enabled or not */ -inline void AddRenderersToRenderList(BufferIndex updateBufferIndex, - RenderList& renderList, - RenderableContainer& renderers, - const Matrix& viewMatrix, - SceneGraph::Camera& camera, - bool isLayer3d, - bool viewportSet, - const Viewport& viewport, - bool cull) +inline void AddRenderersToRenderList(BufferIndex updateBufferIndex, + RenderList& renderList, + RenderableContainer& renderers, + const Matrix& viewMatrix, + const SceneGraph::Camera& camera, + bool isLayer3d, + bool viewportSet, + const Viewport& viewport, + bool cull) { DALI_LOG_INFO(gRenderListLogFilter, Debug::Verbose, "AddRenderersToRenderList()\n"); @@ -459,7 +463,7 @@ RenderInstructionProcessor::RenderInstructionProcessor() RenderInstructionProcessor::~RenderInstructionProcessor() = default; -inline void RenderInstructionProcessor::SortRenderItems(BufferIndex bufferIndex, RenderList& renderList, Layer& layer, bool respectClippingOrder) +inline void RenderInstructionProcessor::SortRenderItems(BufferIndex bufferIndex, RenderList& renderList, Layer& layer, bool respectClippingOrder, bool isOrthographicCamera) { const uint32_t renderableCount = static_cast(renderList.Count()); // Reserve space if needed. @@ -480,47 +484,40 @@ inline void RenderInstructionProcessor::SortRenderItems(BufferIndex bufferIndex, // Calculate the sorting value, once per item by calling the layers sort function. // Using an if and two for-loops rather than if inside for as its better for branch prediction. - if(layer.UsesDefaultSortFunction()) - { - for(uint32_t index = 0; index < renderableCount; ++index) - { - RenderItem& item = renderList.GetItem(index); - if(DALI_LIKELY(item.mRenderer)) - { - item.mRenderer->SetSortAttributes(mSortingHelper[index]); - } + // List of zValue calculating functions. + const Dali::Layer::SortFunctionType zValueFunctionFromVector3[] = { + [](const Vector3& position) { return position.z; }, + [](const Vector3& position) { return position.LengthSquared(); }, + layer.GetSortFunction(), + }; - // texture set - mSortingHelper[index].textureSet = item.mTextureSet; + // Determine whether we need to use zValue as Euclidean distance or translatoin's z value. + // If layer is LAYER_UI or camera is OrthographicProjection mode, we don't need to calculate + // renderItem's distance from camera. - // The default sorting function should get inlined here. - mSortingHelper[index].zValue = Internal::Layer::ZValue(item.mModelViewMatrix.GetTranslation3()) - static_cast(item.mDepthIndex); + // Here we determine which zValue SortFunctionType (of the 3) to use. + // 0 is position z value : Default LAYER_UI or Orthographic camera + // 1 is distance square value : Default LAYER_3D and Perspective camera + // 2 is user defined function. + const int zValueFunctionIndex = layer.UsesDefaultSortFunction() ? ((layer.GetBehavior() == Dali::Layer::LAYER_UI || isOrthographicCamera) ? 0 : 1) : 2; - // Keep the renderitem pointer in the helper so we can quickly reorder items after sort. - mSortingHelper[index].renderItem = &item; - } - } - else + for(uint32_t index = 0; index < renderableCount; ++index) { - const Dali::Layer::SortFunctionType sortFunction = layer.GetSortFunction(); - for(uint32_t index = 0; index < renderableCount; ++index) - { - RenderItem& item = renderList.GetItem(index); + RenderItem& item = renderList.GetItem(index); - if(DALI_LIKELY(item.mRenderer)) - { - item.mRenderer->SetSortAttributes(mSortingHelper[index]); - } + if(DALI_LIKELY(item.mRenderer)) + { + item.mRenderer->SetSortAttributes(mSortingHelper[index]); + } - // texture set - mSortingHelper[index].textureSet = item.mTextureSet; + // texture set + mSortingHelper[index].textureSet = item.mTextureSet; - mSortingHelper[index].zValue = (*sortFunction)(item.mModelViewMatrix.GetTranslation3()) - static_cast(item.mDepthIndex); + mSortingHelper[index].zValue = zValueFunctionFromVector3[zValueFunctionIndex](item.mModelViewMatrix.GetTranslation3()) - static_cast(item.mDepthIndex); - // Keep the RenderItem pointer in the helper so we can quickly reorder items after sort. - mSortingHelper[index].renderItem = &item; - } + // Keep the renderitem pointer in the helper so we can quickly reorder items after sort. + mSortingHelper[index].renderItem = &item; } // Here we determine which comparitor (of the 3) to use. @@ -555,8 +552,9 @@ void RenderInstructionProcessor::Prepare(BufferIndex updateBuffe bool isRenderListAdded = false; bool isRootLayerDirty = false; - const Matrix& viewMatrix = renderTask.GetViewMatrix(updateBufferIndex); - SceneGraph::Camera& camera = renderTask.GetCamera(); + const Matrix& viewMatrix = renderTask.GetViewMatrix(updateBufferIndex); + const SceneGraph::Camera& camera = renderTask.GetCamera(); + const bool isOrthographicCamera = camera.mProjectionMode == Dali::Camera::ProjectionMode::ORTHOGRAPHIC_PROJECTION; Viewport viewport; bool viewportSet = renderTask.QueryViewport(updateBufferIndex, viewport); @@ -565,7 +563,7 @@ void RenderInstructionProcessor::Prepare(BufferIndex updateBuffe for(SortedLayersIter iter = sortedLayers.begin(); iter != endIter; ++iter) { Layer& layer = **iter; - const bool tryReuseRenderList(viewMatrixHasNotChanged && layer.CanReuseRenderers(&renderTask.GetCamera())); + const bool tryReuseRenderList(viewMatrixHasNotChanged && layer.CanReuseRenderers(&camera)); const bool isLayer3D = layer.GetBehavior() == Dali::Layer::LAYER_3D; RenderList* renderList = nullptr; @@ -593,7 +591,7 @@ void RenderInstructionProcessor::Prepare(BufferIndex updateBuffe cull); // We only use the clipping version of the sort comparitor if any clipping nodes exist within the RenderList. - SortRenderItems(updateBufferIndex, *renderList, layer, hasClippingNodes); + SortRenderItems(updateBufferIndex, *renderList, layer, hasClippingNodes, isOrthographicCamera); } isRenderListAdded = true; @@ -617,7 +615,7 @@ void RenderInstructionProcessor::Prepare(BufferIndex updateBuffe cull); // Clipping hierarchy is irrelevant when sorting overlay items, so we specify using the non-clipping version of the sort comparitor. - SortRenderItems(updateBufferIndex, *renderList, layer, false); + SortRenderItems(updateBufferIndex, *renderList, layer, false, isOrthographicCamera); } isRenderListAdded = true;