X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fupdate%2Frendering%2Fscene-graph-renderer.cpp;h=e821f6ead4a555b8c8d6590ed09e3df664b62538;hb=35952536d36e03b9ddf5356a8844a959644bbf55;hp=169be5c82172fe90d257d7a1d9a0451434811913;hpb=4f6cc67ac85e504f3be6e05a9560a3fc862a0a6d;p=platform%2Fcore%2Fuifw%2Fdali-core.git

diff --git a/dali/internal/update/rendering/scene-graph-renderer.cpp b/dali/internal/update/rendering/scene-graph-renderer.cpp
index 169be5c..e821f6e 100644
--- 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 ),
@@ -158,12 +166,12 @@ Renderer::~Renderer()
   if( mTextureSet )
   {
     mTextureSet->RemoveObserver( this );
-    mTextureSet = NULL;
+    mTextureSet = nullptr;
   }
   if( mShader )
   {
     mShader->RemoveConnectionObserver( *this );
-    mShader = NULL;
+    mShader = nullptr;
   }
 }
 
@@ -222,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;
   }
 }
@@ -373,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 )
   {
@@ -436,7 +458,7 @@ void Renderer::SetBlendColor( const Vector4& blendColor )
 {
   if( blendColor == Color::TRANSPARENT )
   {
-    mBlendColor = NULL;
+    mBlendColor = nullptr;
   }
   else
   {
@@ -624,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()
@@ -722,7 +744,7 @@ void Renderer::TextureSetChanged()
 
 void Renderer::TextureSetDeleted()
 {
-  mTextureSet = NULL;
+  mTextureSet = nullptr;
 
   mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
 
@@ -751,10 +773,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