Created PartialRenderingDataProvider to store per-frame data

[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 d1c332c..7508c73 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) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
@@ -31,7 +31,6 @@
 #include <dali/internal/render/common/render-instruction-container.h>
 #include <dali/internal/render/shaders/scene-graph-shader.h>
 #include <dali/internal/render/renderers/render-renderer.h>
-#include <dali/internal/render/renderers/render-property-buffer.h>
 #include <dali/internal/update/nodes/scene-graph-layer.h>
 
 namespace
@@ -151,45 +150,62 @@ bool CompareItems3DWithClipping( const RenderInstructionProcessor::SortAttribute
  * @param isLayer3d Whether we are processing a 3D layer or not
  * @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 cull )
+inline void AddRendererToRenderList(BufferIndex updateBufferIndex,
+                                    RenderList& renderList,
+                                    Renderable& renderable,
+                                    const Matrix& viewMatrix,
+                                    SceneGraph::Camera& camera,
+                                    bool isLayer3d,
+                                    bool cull)
 {
-  bool inside( true );
+  bool inside(true);
   Node* node = renderable.mNode;
 
-  if( cull && renderable.mRenderer && !renderable.mRenderer->GetShader().HintEnabled( Dali::Shader::Hint::MODIFIES_GEOMETRY ) )
+  if (cull && renderable.mRenderer && !renderable.mRenderer->GetShader().HintEnabled(Dali::Shader::Hint::MODIFIES_GEOMETRY))
   {
     const Vector4& boundingSphere = node->GetBoundingSphere();
-    inside = ( boundingSphere.w > Math::MACHINE_EPSILON_1000 ) &&
-             ( camera.CheckSphereInFrustum( updateBufferIndex, Vector3( boundingSphere ), boundingSphere.w ) );
+    inside = (boundingSphere.w > Math::MACHINE_EPSILON_1000) &&
+             (camera.CheckSphereInFrustum(updateBufferIndex, Vector3(boundingSphere), boundingSphere.w));
   }
 
-  if( inside )
+  if (inside)
   {
     Renderer::OpacityType opacityType = renderable.mRenderer ? renderable.mRenderer->GetOpacityType( updateBufferIndex, *renderable.mNode ) : Renderer::OPAQUE;
-    if( opacityType != Renderer::TRANSPARENT || node->GetClippingMode() == ClippingMode::CLIP_CHILDREN )
+    if (opacityType != Renderer::TRANSPARENT || node->GetClippingMode() == ClippingMode::CLIP_CHILDREN)
     {
       // Get the next free RenderItem.
       RenderItem& item = renderList.GetNextFreeItem();
 
+      // Get cached values
+      auto& partialRenderingData = node->GetPartialRenderingData();
+
+      auto& partialRenderingCacheInfo = node->GetPartialRenderingData().GetCurrentCacheInfo();
+
+      partialRenderingCacheInfo.node = node;
+      partialRenderingCacheInfo.isOpaque = (opacityType == Renderer::OPAQUE);
+      partialRenderingCacheInfo.renderer = renderable.mRenderer;
+      partialRenderingCacheInfo.color = renderable.mNode->GetColor(updateBufferIndex);
+      partialRenderingCacheInfo.depthIndex = renderable.mNode->GetDepthIndex();
+
+      if( renderable.mRenderer )
+      {
+        partialRenderingCacheInfo.textureSet = renderable.mRenderer->GetTextures();
+      }
+
       item.mNode = renderable.mNode;
-      item.mIsOpaque = ( opacityType == Renderer::OPAQUE );
-      item.mDepthIndex = 0;
+      item.mIsOpaque = (opacityType == Renderer::OPAQUE);
+      item.mColor = renderable.mNode->GetColor(updateBufferIndex);
 
-      if(!isLayer3d)
+      item.mDepthIndex = 0;
+      if (!isLayer3d)
       {
         item.mDepthIndex = renderable.mNode->GetDepthIndex();
       }
 
-      if( DALI_LIKELY( renderable.mRenderer ) )
+      if (DALI_LIKELY(renderable.mRenderer))
       {
-        item.mRenderer =   &renderable.mRenderer->GetRenderer();
-        item.mTextureSet =  renderable.mRenderer->GetTextures();
+        item.mRenderer = &renderable.mRenderer->GetRenderer();
+        item.mTextureSet = renderable.mRenderer->GetTextures();
         item.mDepthIndex += renderable.mRenderer->GetDepthIndex();
       }
       else
@@ -197,17 +213,34 @@ inline void AddRendererToRenderList( BufferIndex updateBufferIndex,
         item.mRenderer = nullptr;
       }
 
+      item.mIsUpdated |= isLayer3d;
+
       // Save ModelView matrix onto the item.
       node->GetWorldMatrixAndSize( item.mModelMatrix, item.mSize );
-
       Matrix::Multiply( item.mModelViewMatrix, item.mModelMatrix, viewMatrix );
-    }
 
-     node->SetCulled( updateBufferIndex, false );
+      partialRenderingCacheInfo.matrix = item.mModelViewMatrix;
+      partialRenderingCacheInfo.size = item.mSize;
+
+      if (item.mUpdateSize == Vector3::ZERO)
+      {
+        // RenderItem::CalculateViewportSpaceAABB cannot cope with z transform
+        // I don't use item.mModelMatrix.GetTransformComponents() for z transform, would be to slow
+        if (!isLayer3d && item.mModelMatrix.GetZAxis() == Vector3(0.0f, 0.0f, 1.0f))
+        {
+          item.mUpdateSize = item.mSize;
+        }
+      }
+      partialRenderingCacheInfo.updatedSize = item.mUpdateSize;
+
+      item.mIsUpdated = partialRenderingData.IsUpdated() || item.mIsUpdated;
+      partialRenderingData.SwapBuffers();
+    }
+    node->SetCulled( updateBufferIndex, false );
   }
   else
   {
-     node->SetCulled( updateBufferIndex, true );
+    node->SetCulled( updateBufferIndex, true );
   }
 }
 
@@ -240,7 +273,7 @@ inline void AddRenderersToRenderList( BufferIndex updateBufferIndex,
                              viewMatrix,
                              camera,
                              isLayer3d,
-                             cull );
+                             cull);
   }
 }
 
@@ -280,6 +313,7 @@ inline bool TryReuseCachedRenderers( Layer& layer,
       retValue = true;
     }
   }
+
   return retValue;
 }
 
@@ -311,9 +345,7 @@ RenderInstructionProcessor::RenderInstructionProcessor()
   mSortComparitors.PushBack( CompareItems3DWithClipping );
 }
 
-RenderInstructionProcessor::~RenderInstructionProcessor()
-{
-}
+RenderInstructionProcessor::~RenderInstructionProcessor() = default;
 
 inline void RenderInstructionProcessor::SortRenderItems( BufferIndex bufferIndex, RenderList& renderList, Layer& layer, bool respectClippingOrder )
 {
@@ -404,10 +436,10 @@ void RenderInstructionProcessor::Prepare( BufferIndex updateBufferIndex,
 {
   // Retrieve the RenderInstruction buffer from the RenderInstructionContainer
   // then populate with instructions.
-  RenderInstruction& instruction = instructions.GetNextInstruction( updateBufferIndex );
-  renderTask.PrepareRenderInstruction( instruction, updateBufferIndex );
+  RenderInstruction& instruction = renderTask.PrepareRenderInstruction( updateBufferIndex );
   bool viewMatrixHasNotChanged = !renderTask.ViewMatrixUpdated();
   bool isRenderListAdded = false;
+  bool isRootLayerDirty = false;
 
   const Matrix& viewMatrix = renderTask.GetViewMatrix( updateBufferIndex );
   SceneGraph::Camera& camera = renderTask.GetCamera();
@@ -418,7 +450,13 @@ void RenderInstructionProcessor::Prepare( BufferIndex updateBufferIndex,
     Layer& layer = **iter;
     const bool tryReuseRenderList( viewMatrixHasNotChanged && layer.CanReuseRenderers( &renderTask.GetCamera() ) );
     const bool isLayer3D = layer.GetBehavior() == Dali::Layer::LAYER_3D;
-    RenderList* renderList = NULL;
+    RenderList* renderList = nullptr;
+
+    if( layer.IsRoot() && ( layer.GetDirtyFlags() != NodePropertyFlags::NOTHING ) )
+    {
+      // If root-layer & dirty, i.e. a property has changed or a child has been deleted, then we need to ensure we render once more
+      isRootLayerDirty = true;
+    }
 
     if( !layer.colorRenderables.Empty() )
     {
@@ -468,9 +506,9 @@ void RenderInstructionProcessor::Prepare( BufferIndex updateBufferIndex,
   // Inform the render instruction that all renderers have been added and this frame is complete.
   instruction.UpdateCompleted();
 
-  if( !isRenderListAdded && !instruction.mIsClearColorSet )
+  if( isRenderListAdded || instruction.mIsClearColorSet || isRootLayerDirty )
   {
-    instructions.DiscardCurrentInstruction( updateBufferIndex );
+    instructions.PushBack( updateBufferIndex, &instruction );
   }
 }