Make blend for the opaque renderer when advanced blend equation is applied.

[platform/core/uifw/dali-core.git] / dali / internal / update / rendering / scene-graph-renderer.cpp

diff --git a/dali/internal/update/rendering/scene-graph-renderer.cpp b/dali/internal/update/rendering/scene-graph-renderer.cpp
index ad0974b..1039a8d 100644 (file)
--- a/dali/internal/update/rendering/scene-graph-renderer.cpp
+++ b/dali/internal/update/rendering/scene-graph-renderer.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.
@@ -29,6 +29,7 @@
 #include <dali/internal/render/renderers/render-geometry.h>
 #include <dali/internal/render/shaders/program.h>
 #include <dali/internal/render/shaders/scene-graph-shader.h>
+#include <dali/internal/common/blending-options.h>
 
 namespace Dali
 {
@@ -49,8 +50,14 @@ MemoryPoolObjectAllocator<Renderer> gRendererMemoryPool;
 void AddMappings( CollectedUniformMap& localMap, const UniformMap& uniformMap )
 {
   // Iterate thru uniformMap.
-  //   Any maps that aren't in localMap should be added in a single step
-  CollectedUniformMap newUniformMappings;
+  // Any maps that aren't in localMap should be added in a single step
+
+  // keep a static vector to avoid temporary heap allocation.
+  // As this function gets called only from update thread we don't have to
+  // make it thread safe (so no need to keep a thread_local variable).
+  static CollectedUniformMap newUniformMappings;
+
+  newUniformMappings.Clear();
 
   for( UniformMap::SizeType i = 0, count=uniformMap.Count(); i<count; ++i )
   {
@@ -114,6 +121,7 @@ enum Flags
   RESEND_STENCIL_OPERATION_ON_Z_PASS = 1 << 17,
   RESEND_WRITE_TO_COLOR_BUFFER       = 1 << 18,
   RESEND_SHADER                      = 1 << 19,
+  RESEND_DRAW_COMMANDS               = 1 << 20
 };
 
 } // Anonymous namespace
@@ -124,13 +132,13 @@ Renderer* Renderer::New()
 }
 
 Renderer::Renderer()
-: mSceneController( 0 ),
-  mRenderer( NULL ),
-  mTextureSet( NULL ),
-  mGeometry( NULL ),
-  mShader( NULL ),
-  mRenderDataProvider( NULL ),
-  mBlendColor( NULL ),
+: mSceneController( nullptr ),
+  mRenderer( nullptr ),
+  mTextureSet( nullptr ),
+  mGeometry( nullptr ),
+  mShader( nullptr ),
+  mRenderDataProvider( nullptr ),
+  mBlendColor( nullptr ),
   mStencilParameters( RenderMode::AUTO, StencilFunction::ALWAYS, 0xFF, 0x00, 0xFF, StencilOperation::KEEP, StencilOperation::KEEP, StencilOperation::KEEP ),
   mIndexedDrawFirstElement( 0u ),
   mIndexedDrawElementsCount( 0u ),
@@ -159,12 +167,12 @@ Renderer::~Renderer()
   if( mTextureSet )
   {
     mTextureSet->RemoveObserver( this );
-    mTextureSet = NULL;
+    mTextureSet = nullptr;
   }
   if( mShader )
   {
     mShader->RemoveConnectionObserver( *this );
-    mShader = NULL;
+    mShader = nullptr;
   }
 }
 
@@ -174,7 +182,7 @@ void Renderer::operator delete( void* ptr )
 }
 
 
-void Renderer::PrepareRender( BufferIndex updateBufferIndex )
+bool Renderer::PrepareRender( BufferIndex updateBufferIndex )
 {
   if( mRegenerateUniformMap == UNIFORM_MAP_READY )
   {
@@ -214,6 +222,8 @@ void Renderer::PrepareRender( BufferIndex updateBufferIndex )
     mRegenerateUniformMap--;
   }
 
+  bool rendererUpdated = mUniformMapChanged[updateBufferIndex] || mResendFlag;
+
   if( mResendFlag != 0 )
   {
     if( mResendFlag & RESEND_GEOMETRY )
@@ -223,134 +233,143 @@ void Renderer::PrepareRender( BufferIndex updateBufferIndex )
       new (slot) DerivedType( mRenderer, &Render::Renderer::SetGeometry, mGeometry );
     }
 
+    if( mResendFlag & RESEND_DRAW_COMMANDS )
+    {
+      using DerivedType = MessageValue2<Render::Renderer, Dali::DevelRenderer::DrawCommand*, uint32_t>;
+      uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
+      new (slot) DerivedType( mRenderer, &Render::Renderer::SetDrawCommands, mDrawCommands.data(), mDrawCommands.size() );
+    }
+
     if( mResendFlag & RESEND_FACE_CULLING_MODE )
     {
-      typedef MessageValue1< Render::Renderer, FaceCullingMode::Type > DerivedType;
+      using DerivedType = MessageValue1<Render::Renderer, FaceCullingMode::Type>;
       uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
       new (slot) DerivedType( mRenderer, &Render::Renderer::SetFaceCullingMode, mFaceCullingMode );
     }
 
     if( mResendFlag & RESEND_BLEND_BIT_MASK )
     {
-      typedef MessageValue1< Render::Renderer, uint32_t > DerivedType;
+      using DerivedType = MessageValue1<Render::Renderer, uint32_t>;
       uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
       new (slot) DerivedType( mRenderer, &Render::Renderer::SetBlendingBitMask, mBlendBitmask );
     }
 
     if( mResendFlag & RESEND_BLEND_COLOR )
     {
-      typedef MessageValue1< Render::Renderer, Vector4 > DerivedType;
+      using DerivedType = MessageValue1<Render::Renderer, Vector4>;
       uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
       new (slot) DerivedType( mRenderer, &Render::Renderer::SetBlendColor, GetBlendColor() );
     }
 
     if( mResendFlag & RESEND_PREMULTIPLIED_ALPHA  )
     {
-      typedef MessageValue1< Render::Renderer, bool > DerivedType;
+      using DerivedType = MessageValue1<Render::Renderer, bool>;
       uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
       new (slot) DerivedType( mRenderer, &Render::Renderer::EnablePreMultipliedAlpha, mPremultipledAlphaEnabled );
     }
 
     if( mResendFlag & RESEND_INDEXED_DRAW_FIRST_ELEMENT )
     {
-      typedef MessageValue1< Render::Renderer, uint32_t > DerivedType;
+      using DerivedType = MessageValue1<Render::Renderer, uint32_t>;
       uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
       new (slot) DerivedType( mRenderer, &Render::Renderer::SetIndexedDrawFirstElement, mIndexedDrawFirstElement );
     }
 
     if( mResendFlag & RESEND_INDEXED_DRAW_ELEMENTS_COUNT )
     {
-      typedef MessageValue1< Render::Renderer, uint32_t > DerivedType;
+      using DerivedType = MessageValue1<Render::Renderer, uint32_t>;
       uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
       new (slot) DerivedType( mRenderer, &Render::Renderer::SetIndexedDrawElementsCount, mIndexedDrawElementsCount );
     }
 
     if( mResendFlag & RESEND_DEPTH_WRITE_MODE )
     {
-      typedef MessageValue1< Render::Renderer, DepthWriteMode::Type > DerivedType;
+      using DerivedType = MessageValue1<Render::Renderer, DepthWriteMode::Type>;
       uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
       new (slot) DerivedType( mRenderer, &Render::Renderer::SetDepthWriteMode, mDepthWriteMode );
     }
 
     if( mResendFlag & RESEND_DEPTH_TEST_MODE )
     {
-      typedef MessageValue1< Render::Renderer, DepthTestMode::Type > DerivedType;
+      using DerivedType = MessageValue1<Render::Renderer, DepthTestMode::Type>;
       uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
       new (slot) DerivedType( mRenderer, &Render::Renderer::SetDepthTestMode, mDepthTestMode );
     }
 
     if( mResendFlag & RESEND_DEPTH_FUNCTION )
     {
-      typedef MessageValue1< Render::Renderer, DepthFunction::Type > DerivedType;
+      using DerivedType = MessageValue1<Render::Renderer, DepthFunction::Type>;
       uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
       new (slot) DerivedType( mRenderer, &Render::Renderer::SetDepthFunction, mDepthFunction );
     }
 
     if( mResendFlag & RESEND_RENDER_MODE )
     {
-      typedef MessageValue1< Render::Renderer, RenderMode::Type > DerivedType;
+      using DerivedType = MessageValue1<Render::Renderer, RenderMode::Type>;
       uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
       new (slot) DerivedType( mRenderer, &Render::Renderer::SetRenderMode, mStencilParameters.renderMode );
     }
 
     if( mResendFlag & RESEND_STENCIL_FUNCTION )
     {
-      typedef MessageValue1< Render::Renderer, StencilFunction::Type > DerivedType;
+      using DerivedType = MessageValue1<Render::Renderer, StencilFunction::Type>;
       uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
       new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilFunction, mStencilParameters.stencilFunction );
     }
 
     if( mResendFlag & RESEND_STENCIL_FUNCTION_MASK )
     {
-      typedef MessageValue1< Render::Renderer, int > DerivedType;
+      using DerivedType = MessageValue1<Render::Renderer, int>;
       uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
       new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilFunctionMask, mStencilParameters.stencilFunctionMask );
     }
 
     if( mResendFlag & RESEND_STENCIL_FUNCTION_REFERENCE )
     {
-      typedef MessageValue1< Render::Renderer, int > DerivedType;
+      using DerivedType = MessageValue1<Render::Renderer, int>;
       uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
       new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilFunctionReference, mStencilParameters.stencilFunctionReference );
     }
 
     if( mResendFlag & RESEND_STENCIL_MASK )
     {
-      typedef MessageValue1< Render::Renderer, int > DerivedType;
+      using DerivedType = MessageValue1<Render::Renderer, int>;
       uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
       new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilMask, mStencilParameters.stencilMask );
     }
 
     if( mResendFlag & RESEND_STENCIL_OPERATION_ON_FAIL )
     {
-      typedef MessageValue1< Render::Renderer, StencilOperation::Type > DerivedType;
+      using DerivedType = MessageValue1<Render::Renderer, StencilOperation::Type>;
       uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
       new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilOperationOnFail, mStencilParameters.stencilOperationOnFail );
     }
 
     if( mResendFlag & RESEND_STENCIL_OPERATION_ON_Z_FAIL )
     {
-      typedef MessageValue1< Render::Renderer, StencilOperation::Type > DerivedType;
+      using DerivedType = MessageValue1<Render::Renderer, StencilOperation::Type>;
       uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
       new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilOperationOnZFail, mStencilParameters.stencilOperationOnZFail );
     }
 
     if( mResendFlag & RESEND_STENCIL_OPERATION_ON_Z_PASS )
     {
-      typedef MessageValue1< Render::Renderer, StencilOperation::Type > DerivedType;
+      using DerivedType = MessageValue1<Render::Renderer, StencilOperation::Type>;
       uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
       new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilOperationOnZPass, mStencilParameters.stencilOperationOnZPass );
     }
 
     if( mResendFlag & RESEND_SHADER )
     {
-      typedef MessageValue1< Render::Renderer, bool > DerivedType;
+      using DerivedType = MessageValue1<Render::Renderer, bool>;
       uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
       new (slot) DerivedType( mRenderer, &Render::Renderer::SetShaderChanged, true );
     }
 
     mResendFlag = 0;
   }
+
+  return rendererUpdated;
 }
 
 void Renderer::SetTextures( TextureSet* textureSet )
@@ -444,7 +463,7 @@ void Renderer::SetBlendColor( const Vector4& blendColor )
 {
   if( blendColor == Color::TRANSPARENT )
   {
-    mBlendColor = NULL;
+    mBlendColor = nullptr;
   }
   else
   {
@@ -632,10 +651,10 @@ void Renderer::DisconnectFromSceneGraph( SceneController& sceneController, Buffe
   if( mRenderer )
   {
     mSceneController->GetRenderMessageDispatcher().RemoveRenderer( *mRenderer );
-    mRenderer = NULL;
+    mRenderer = nullptr;
   }
-  mSceneController = NULL;
-  mRenderDataProvider = NULL;
+  mSceneController = nullptr;
+  mRenderDataProvider = nullptr;
 }
 
 void Renderer::UpdateTextureSet()
@@ -692,6 +711,12 @@ Renderer::OpacityType Renderer::GetOpacityType( BufferIndex updateBufferIndex, c
     }
     case BlendMode::AUTO:
     {
+      if(BlendingOptions::IsAdvancedBlendEquationIncluded(mBlendBitmask))
+      {
+        opacityType = Renderer::TRANSLUCENT;
+        break;
+      }
+
       bool shaderRequiresBlending( mShader->HintEnabled( Dali::Shader::Hint::OUTPUT_IS_TRANSPARENT ) );
       if( shaderRequiresBlending || ( mTextureSet && mTextureSet->HasAlpha() ) )
       {
@@ -708,6 +733,7 @@ Renderer::OpacityType Renderer::GetOpacityType( BufferIndex updateBufferIndex, c
       {
         opacityType = Renderer::TRANSLUCENT;
       }
+
       break;
     }
     case BlendMode::OFF: // the renderer should never use blending
@@ -730,7 +756,7 @@ void Renderer::TextureSetChanged()
 
 void Renderer::TextureSetDeleted()
 {
-  mTextureSet = NULL;
+  mTextureSet = nullptr;
 
   mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
 
@@ -759,10 +785,17 @@ void Renderer::ObservedObjectDestroyed(PropertyOwner& owner)
 {
   if( reinterpret_cast<PropertyOwner*>(mShader) == &owner )
   {
-    mShader = NULL;
+    mShader = nullptr;
   }
 }
 
+void Renderer::SetDrawCommands( Dali::DevelRenderer::DrawCommand* pDrawCommands, uint32_t size )
+{
+  mDrawCommands.clear();
+  mDrawCommands.insert( mDrawCommands.end(), pDrawCommands, pDrawCommands+size );
+  mResendFlag |= RESEND_DRAW_COMMANDS;
+}
+
 } // namespace SceneGraph
 } // namespace Internal
 } // namespace Dali