Get world scale more faster

[platform/core/uifw/dali-core.git] / dali / internal / update / manager / render-instruction-processor.cpp

diff --git a/dali/internal/update/manager/render-instruction-processor.cpp b/dali/internal/update/manager/render-instruction-processor.cpp
index 3bc7f79..87c3c98 100644 (file)
--- a/dali/internal/update/manager/render-instruction-processor.cpp
+++ b/dali/internal/update/manager/render-instruction-processor.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2023 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.
@@ -199,14 +199,13 @@ inline void AddRendererToRenderList(BufferIndex               updateBufferIndex,
   Vector3 nodeSize;
   Vector4 nodeUpdateArea;
   bool    nodeUpdateAreaSet(false);
-  bool    nodeUpdateAreaUseHint(false);
   Matrix  nodeModelViewMatrix(false);
   bool    nodeModelViewMatrixSet(false);
 
   // Don't cull items which have render callback
   bool hasRenderCallback = (renderable.mRenderer && renderable.mRenderer->GetRenderCallback());
 
-  if(cull && renderable.mRenderer && (hasRenderCallback || (!renderable.mRenderer->GetShader().HintEnabled(Dali::Shader::Hint::MODIFIES_GEOMETRY) && node->GetClippingMode() == ClippingMode::DISABLED)))
+  if(cull && renderable.mRenderer && !hasRenderCallback && !renderable.mRenderer->GetShader().HintEnabled(Dali::Shader::Hint::MODIFIES_GEOMETRY) && node->GetClippingMode() == ClippingMode::DISABLED)
   {
     const Vector4& boundingSphere = node->GetBoundingSphere();
     inside                        = (boundingSphere.w > Math::MACHINE_EPSILON_1000) &&
@@ -214,15 +213,15 @@ inline void AddRendererToRenderList(BufferIndex               updateBufferIndex,
 
     if(inside && !isLayer3d && viewportSet)
     {
-      nodeUpdateAreaUseHint = SetNodeUpdateArea(node, isLayer3d, nodeWorldMatrix, nodeSize, nodeUpdateArea);
-      nodeUpdateAreaSet     = true;
+      SetNodeUpdateArea(node, isLayer3d, nodeWorldMatrix, nodeSize, nodeUpdateArea);
+      nodeUpdateAreaSet = true;
 
-      const Vector3& scale = node->GetWorldScale(updateBufferIndex);
+      const Vector3& scale = nodeWorldMatrix.GetScale();
       const Vector3& size  = Vector3(nodeUpdateArea.z, nodeUpdateArea.w, 1.0f) * scale;
 
       if(size.LengthSquared() > Math::MACHINE_EPSILON_1000)
       {
-        MatrixUtils::Multiply(nodeModelViewMatrix, nodeWorldMatrix, viewMatrix);
+        MatrixUtils::MultiplyTransformMatrix(nodeModelViewMatrix, nodeWorldMatrix, viewMatrix);
         nodeModelViewMatrixSet = true;
 
         // Assume actors are at z=0, compute AABB in view space & test rect intersection
@@ -261,70 +260,40 @@ inline void AddRendererToRenderList(BufferIndex               updateBufferIndex,
       // Get the next free RenderItem.
       RenderItem& item = renderList.GetNextFreeItem();
 
-      PartialRenderingData partialRenderingData;
-
-      partialRenderingData.node       = node;
-      partialRenderingData.renderer   = renderable.mRenderer;
-      partialRenderingData.color      = node->GetWorldColor(updateBufferIndex);
-      partialRenderingData.depthIndex = node->GetDepthIndex();
-      partialRenderingData.isOpaque   = isOpaque;
-
-      partialRenderingData.textureSet = nullptr;
-      if(DALI_LIKELY(renderable.mRenderer))
-      {
-        partialRenderingData.color.a *= renderable.mRenderer->GetOpacity(updateBufferIndex);
-        partialRenderingData.textureSet = renderable.mRenderer->GetTextureSet();
-      }
-
-      item.mNode     = node;
-      item.mIsOpaque = isOpaque;
-      item.mColor    = node->GetColor(updateBufferIndex);
-
-      item.mDepthIndex = 0;
-      if(!isLayer3d)
-      {
-        item.mDepthIndex = node->GetDepthIndex();
-      }
+      item.mNode       = node;
+      item.mIsOpaque   = isOpaque;
+      item.mDepthIndex = isLayer3d ? 0 : node->GetDepthIndex();
 
       if(DALI_LIKELY(renderable.mRenderer))
       {
-        item.mRenderer   = &renderable.mRenderer->GetRenderer();
+        item.mRenderer   = renderable.mRenderer->GetRenderer();
         item.mTextureSet = renderable.mRenderer->GetTextureSet();
         item.mDepthIndex += renderable.mRenderer->GetDepthIndex();
-
-        // Get whether collected map is up to date
-        item.mIsUpdated |= renderable.mRenderer->UniformMapUpdated();
       }
       else
       {
-        item.mRenderer = nullptr;
+        item.mRenderer = Render::RendererKey{};
       }
 
       item.mIsUpdated |= isLayer3d;
 
       if(!nodeUpdateAreaSet)
       {
-        nodeUpdateAreaUseHint = SetNodeUpdateArea(node, isLayer3d, nodeWorldMatrix, nodeSize, nodeUpdateArea);
+        SetNodeUpdateArea(node, isLayer3d, nodeWorldMatrix, nodeSize, nodeUpdateArea);
       }
 
       item.mSize        = nodeSize;
       item.mUpdateArea  = nodeUpdateArea;
       item.mModelMatrix = nodeWorldMatrix;
 
-      // Apply transform informations if node doesn't have update size hint and use VisualRenderer.
-      if(!nodeUpdateAreaUseHint && renderable.mRenderer && renderable.mRenderer->GetVisualProperties())
-      {
-        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)
       {
-        MatrixUtils::Multiply(nodeModelViewMatrix, nodeWorldMatrix, viewMatrix);
+        MatrixUtils::MultiplyTransformMatrix(nodeModelViewMatrix, nodeWorldMatrix, viewMatrix);
       }
       item.mModelViewMatrix = nodeModelViewMatrix;
 
+      PartialRenderingData partialRenderingData;
+      partialRenderingData.color               = node->GetWorldColor(updateBufferIndex);
       partialRenderingData.matrix              = item.mModelViewMatrix;
       partialRenderingData.updatedPositionSize = item.mUpdateArea;
       partialRenderingData.size                = item.mSize;
@@ -413,16 +382,17 @@ inline bool TryReuseCachedRenderers(Layer&               layer,
     // Therefore we check a combined sum of all renderer addresses.
     size_t checkSumNew = 0;
     size_t checkSumOld = 0;
+    //@todo just use keys, don't deref.
     for(uint32_t index = 0; index < renderableCount; ++index)
     {
       if(DALI_LIKELY(renderables[index].mRenderer))
       {
-        const Render::Renderer& renderer = renderables[index].mRenderer->GetRenderer();
-        checkSumNew += reinterpret_cast<std::size_t>(&renderer);
+        Render::RendererKey renderer = renderables[index].mRenderer->GetRenderer();
+        checkSumNew += renderer.Value();
       }
       if(DALI_LIKELY(renderList.GetItem(index).mRenderer))
       {
-        checkSumOld += reinterpret_cast<std::size_t>(&renderList.GetRenderer(index));
+        checkSumOld += renderList.GetItem(index).mRenderer.Value();
       }
     }
     if(checkSumNew == checkSumOld)
@@ -489,10 +459,8 @@ inline void RenderInstructionProcessor::SortRenderItems(BufferIndex bufferIndex,
 
   // List of zValue calculating functions.
   const Dali::Layer::SortFunctionType zValueFunctionFromVector3[] = {
-    [](const Vector3& position)
-    { return position.z; },
-    [](const Vector3& position)
-    { return position.LengthSquared(); },
+    [](const Vector3& position) { return position.z; },
+    [](const Vector3& position) { return position.LengthSquared(); },
     layer.GetSortFunction(),
   };
 
@@ -508,8 +476,8 @@ inline void RenderInstructionProcessor::SortRenderItems(BufferIndex bufferIndex,
 
   for(uint32_t index = 0; index < renderableCount; ++index)
   {
-    RenderItem& item = renderList.GetItem(index);
-
+    RenderItemKey itemKey = renderList.GetItemKey(index);
+    RenderItem&   item    = *itemKey.Get();
     if(DALI_LIKELY(item.mRenderer))
     {
       item.mRenderer->SetSortAttributes(mSortingHelper[index]);
@@ -521,7 +489,7 @@ inline void RenderInstructionProcessor::SortRenderItems(BufferIndex bufferIndex,
     mSortingHelper[index].zValue = zValueFunctionFromVector3[zValueFunctionIndex](item.mModelViewMatrix.GetTranslation3()) - static_cast<float>(item.mDepthIndex);
 
     // Keep the renderitem pointer in the helper so we can quickly reorder items after sort.
-    mSortingHelper[index].renderItem = &item;
+    mSortingHelper[index].renderItem = itemKey;
   }
 
   // Here we determine which comparitor (of the 3) to use.
@@ -538,7 +506,7 @@ inline void RenderInstructionProcessor::SortRenderItems(BufferIndex bufferIndex,
   for(uint32_t index = 0; index < renderableCount; ++index, ++renderListIter)
   {
     *renderListIter = mSortingHelper[index].renderItem;
-    DALI_LOG_INFO(gRenderListLogFilter, Debug::Verbose, "  sortedList[%d] = %p\n", index, mSortingHelper[index].renderItem->mRenderer);
+    DALI_LOG_INFO(gRenderListLogFilter, Debug::Verbose, "  sortedList[%d] = %x\n", index, mSortingHelper[index].renderItem->mRenderer);
   }
 }