[Tizen] Revert "Skip rendering if no animation is currently active"

[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
old mode 100755 (executable)
new mode 100644 (file)
index 98f81ef..e821f6e
--- a/dali/internal/update/rendering/scene-graph-renderer.cpp
+++ b/dali/internal/update/rendering/scene-graph-renderer.cpp
@@ -49,8 +49,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 )
   {
@@ -112,7 +118,9 @@ enum Flags
   RESEND_STENCIL_OPERATION_ON_FAIL   = 1 << 15,
   RESEND_STENCIL_OPERATION_ON_Z_FAIL = 1 << 16,
   RESEND_STENCIL_OPERATION_ON_Z_PASS = 1 << 17,
-  RESEND_WRITE_TO_COLOR_BUFFER       = 1 << 18
+  RESEND_WRITE_TO_COLOR_BUFFER       = 1 << 18,
+  RESEND_SHADER                      = 1 << 19,
+  RESEND_DRAW_COMMANDS               = 1 << 20
 };
 
 } // Anonymous namespace
@@ -123,13 +131,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 ),
@@ -143,7 +151,6 @@ Renderer::Renderer()
   mDepthTestMode( DepthTestMode::AUTO ),
   mRenderingBehavior( DevelRenderer::Rendering::IF_REQUIRED ),
   mPremultipledAlphaEnabled( false ),
-  mDirty( false ),
   mOpacity( 1.0f ),
   mDepthIndex( 0 )
 {
@@ -159,12 +166,12 @@ Renderer::~Renderer()
   if( mTextureSet )
   {
     mTextureSet->RemoveObserver( this );
-    mTextureSet = NULL;
+    mTextureSet = nullptr;
   }
   if( mShader )
   {
     mShader->RemoveConnectionObserver( *this );
-    mShader = NULL;
+    mShader = nullptr;
   }
 }
 
@@ -182,7 +189,6 @@ void Renderer::PrepareRender( BufferIndex updateBufferIndex )
   }
   else
   {
-    mDirty = true;
     if( mRegenerateUniformMap == REGENERATE_UNIFORM_MAP)
     {
       CollectedUniformMap& localMap = mCollectedUniformMap[ updateBufferIndex ];
@@ -217,7 +223,6 @@ void Renderer::PrepareRender( BufferIndex updateBufferIndex )
 
   if( mResendFlag != 0 )
   {
-    mDirty = true;
     if( mResendFlag & RESEND_GEOMETRY )
     {
       typedef MessageValue1< Render::Renderer, Render::Geometry* > DerivedType;
@@ -225,125 +230,139 @@ 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 )
+    {
+      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;
   }
 }
@@ -376,7 +395,7 @@ void Renderer::SetShader( Shader* shader )
   mShader = shader;
   mShader->AddConnectionObserver( *this );
   mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
-  mResendFlag |= RESEND_GEOMETRY;
+  mResendFlag |= RESEND_GEOMETRY | RESEND_SHADER;
 
   if( mRenderDataProvider )
   {
@@ -398,7 +417,6 @@ void Renderer::SetGeometry( Render::Geometry* geometry )
 void Renderer::SetDepthIndex( int depthIndex )
 {
   mDepthIndex = depthIndex;
-  mDirty = true;
 }
 
 void Renderer::SetFaceCullingMode( FaceCullingMode::Type faceCullingMode )
@@ -415,7 +433,6 @@ FaceCullingMode::Type Renderer::GetFaceCullingMode() const
 void Renderer::SetBlendMode( BlendMode::Type blendingMode )
 {
   mBlendMode = blendingMode;
-  mDirty = true;
 }
 
 BlendMode::Type Renderer::GetBlendMode() const
@@ -441,7 +458,7 @@ void Renderer::SetBlendColor( const Vector4& blendColor )
 {
   if( blendColor == Color::TRANSPARENT )
   {
-    mBlendColor = NULL;
+    mBlendColor = nullptr;
   }
   else
   {
@@ -588,7 +605,6 @@ const Render::Renderer::StencilParameters& Renderer::GetStencilParameters() cons
 
 void Renderer::BakeOpacity( BufferIndex updateBufferIndex, float opacity )
 {
-  mDirty = true;
   mOpacity.Bake( updateBufferIndex, opacity );
 }
 
@@ -600,7 +616,6 @@ float Renderer::GetOpacity( BufferIndex updateBufferIndex ) const
 void Renderer::SetRenderingBehavior( DevelRenderer::Rendering::Type renderingBehavior )
 {
   mRenderingBehavior = renderingBehavior;
-  mDirty = true;
 }
 
 DevelRenderer::Rendering::Type Renderer::GetRenderingBehavior() const
@@ -619,6 +634,7 @@ void Renderer::ConnectToSceneGraph( SceneController& sceneController, BufferInde
 
   mRenderer = Render::Renderer::New( mRenderDataProvider, mGeometry, mBlendBitmask, GetBlendColor(), static_cast< FaceCullingMode::Type >( mFaceCullingMode ),
                                          mPremultipledAlphaEnabled, mDepthWriteMode, mDepthTestMode, mDepthFunction, mStencilParameters );
+
   OwnerPointer< Render::Renderer > transferOwnership( mRenderer );
   mSceneController->GetRenderMessageDispatcher().AddRenderer( transferOwnership );
 }
@@ -630,10 +646,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()
@@ -656,7 +672,6 @@ void Renderer::UpdateTextureSet()
       mRenderDataProvider->mTextures.clear();
       mRenderDataProvider->mSamplers.clear();
     }
-    mDirty = true;
   }
 }
 
@@ -729,7 +744,7 @@ void Renderer::TextureSetChanged()
 
 void Renderer::TextureSetDeleted()
 {
-  mTextureSet = NULL;
+  mTextureSet = nullptr;
 
   mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
 
@@ -758,48 +773,15 @@ void Renderer::ObservedObjectDestroyed(PropertyOwner& owner)
 {
   if( reinterpret_cast<PropertyOwner*>(mShader) == &owner )
   {
-    mShader = NULL;
-  }
-}
-
-void Renderer::SetDirty( bool value )
-{
-  mDirty = value;
-  if( mShader )
-  {
-    mShader->SetPropertyDirty( value );
+    mShader = nullptr;
   }
 }
 
-bool Renderer::IsDirty() const
+void Renderer::SetDrawCommands( Dali::DevelRenderer::DrawCommand* pDrawCommands, uint32_t size )
 {
-  bool ret = false;
-  if( mShader )
-  {
-    ret = mShader->IsPropertyDirty();
-  }
-
-  // check native image
-  if( mTextureSet )
-  {
-    uint32_t textureCount = mTextureSet->GetTextureCount();
-
-    if(textureCount > 0)
-    {
-      Dali::Internal::Render::Texture* texture;
-      for( uint32_t i = 0; i<textureCount; ++i )
-      {
-        texture = const_cast<Dali::Internal::SceneGraph::TextureSet *>(mTextureSet)->GetTexture(i);
-        if( texture && texture->IsNativeImage() )
-        {
-          ret = true;
-          break;
-        }
-      }
-    }
-  }
-
-  return ret | mDirty;
+  mDrawCommands.clear();
+  mDrawCommands.insert( mDrawCommands.end(), pDrawCommands, pDrawCommands+size );
+  mResendFlag |= RESEND_DRAW_COMMANDS;
 }
 
 } // namespace SceneGraph