Remove old pipeline caches

[platform/core/uifw/dali-core.git] / dali / internal / render / renderers / render-renderer.cpp

diff --git a/dali/internal/render/renderers/render-renderer.cpp b/dali/internal/render/renderers/render-renderer.cpp
index 45aa582..486eb2f 100644 (file)
--- a/dali/internal/render/renderers/render-renderer.cpp
+++ b/dali/internal/render/renderers/render-renderer.cpp
@@ -147,19 +147,19 @@ inline uint32_t GetUniformBufferDataAlignment(uint32_t dataSize)
 }
 
 /**
- * @brief Store latest binded RenderGeometry, and help that we can skip duplicated vertex attributes bind.
+ * @brief Store latest bound RenderGeometry, and help that we can skip duplicated vertex attributes bind.
  *
  * @param[in] geometry Current geometry to be used, or nullptr if render finished
- * @return True if we can reuse latest binded vertex attributes. False otherwise.
+ * @return True if we can reuse latest bound vertex attributes. False otherwise.
  */
-inline bool ReuseLatestBindedVertexAttributes(const Render::Geometry* geometry)
+inline bool ReuseLatestBoundVertexAttributes(const Render::Geometry* geometry)
 {
-  static const Render::Geometry* gLatestVertexBindedGeometry = nullptr;
-  if(gLatestVertexBindedGeometry == geometry)
+  static const Render::Geometry* gLatestVertexBoundGeometry = nullptr;
+  if(gLatestVertexBoundGeometry == geometry)
   {
     return true;
   }
-  gLatestVertexBindedGeometry = geometry;
+  gLatestVertexBoundGeometry = geometry;
   return false;
 }
 
@@ -169,13 +169,17 @@ namespace Render
 {
 namespace
 {
-MemoryPoolObjectAllocator<Renderer> gRenderRendererMemoryPool;
+MemoryPoolObjectAllocator<Renderer>& GetRenderRendererMemoryPool()
+{
+  static MemoryPoolObjectAllocator<Renderer> gRenderRendererMemoryPool;
+  return gRenderRendererMemoryPool;
 }
+} // namespace
 
 void Renderer::PrepareCommandBuffer()
 {
   // Reset latest geometry informations, So we can bind the first of geometry.
-  ReuseLatestBindedVertexAttributes(nullptr);
+  ReuseLatestBoundVertexAttributes(nullptr);
 
   // todo : Fill here as many caches as we can store for reduce the number of command buffers
 }
@@ -191,8 +195,8 @@ RendererKey Renderer::NewKey(SceneGraph::RenderDataProvider* dataProvider,
                              DepthFunction::Type             depthFunction,
                              StencilParameters&              stencilParameters)
 {
-  void* ptr = gRenderRendererMemoryPool.AllocateRawThreadSafe();
-  auto  key = gRenderRendererMemoryPool.GetKeyFromPtr(static_cast<Renderer*>(ptr));
+  void* ptr = GetRenderRendererMemoryPool().AllocateRawThreadSafe();
+  auto  key = GetRenderRendererMemoryPool().GetKeyFromPtr(static_cast<Renderer*>(ptr));
 
   // Use placement new to construct renderer.
   new(ptr) Renderer(dataProvider, geometry, blendingBitmask, blendColor, faceCullingMode, preMultipliedAlphaEnabled, depthWriteMode, depthTestMode, depthFunction, stencilParameters);
@@ -241,16 +245,20 @@ void Renderer::Initialize(Graphics::Controller& graphicsController, ProgramCache
   mPipelineCache        = &pipelineCache;
 }
 
-Renderer::~Renderer() = default;
+Renderer::~Renderer()
+{
+  // Reset old pipeline
+  mPipelineCache->ResetPipeline(mPipeline);
+}
 
 void Renderer::operator delete(void* ptr)
 {
-  gRenderRendererMemoryPool.FreeThreadSafe(static_cast<Renderer*>(ptr));
+  GetRenderRendererMemoryPool().FreeThreadSafe(static_cast<Renderer*>(ptr));
 }
 
 Renderer* Renderer::Get(RendererKey::KeyType rendererKey)
 {
-  return gRenderRendererMemoryPool.GetPtrFromKey(rendererKey);
+  return GetRenderRendererMemoryPool().GetPtrFromKey(rendererKey);
 }
 
 void Renderer::SetGeometry(Render::Geometry* geometry)
@@ -596,8 +604,8 @@ bool Renderer::Render(Graphics::CommandBuffer&                             comma
   bool drawn = false; // Draw can fail if there are no vertex buffers or they haven't been uploaded yet
                       // @todo We should detect this case much earlier to prevent unnecessary work
 
-  // Reuse latest binded vertex attributes location, or Bind buffers to attribute locations.
-  if(ReuseLatestBindedVertexAttributes(mGeometry) || mGeometry->BindVertexAttributes(commandBuffer))
+  // Reuse latest bound vertex attributes location, or Bind buffers to attribute locations.
+  if(ReuseLatestBoundVertexAttributes(mGeometry) || mGeometry->BindVertexAttributes(commandBuffer))
   {
     if(mDrawCommands.empty())
     {
@@ -614,7 +622,7 @@ bool Renderer::Render(Graphics::CommandBuffer&                             comma
   else
   {
     // BindVertexAttributes failed. Reset cached geometry.
-    ReuseLatestBindedVertexAttributes(nullptr);
+    ReuseLatestBoundVertexAttributes(nullptr);
   }
 
   return drawn;
@@ -961,8 +969,16 @@ Graphics::Pipeline& Renderer::PrepareGraphicsPipeline(
   queryInfo.alphaPremultiplied    = mPremultipliedAlphaEnabled;
   queryInfo.cameraUsingReflection = instruction.GetCamera()->GetReflectionUsed();
 
+  queryInfo.GenerateHash();
+
+  // Reset old pipeline
+  mPipelineCache->ResetPipeline(mPipeline);
+
+  // Find or generate new pipeline.
   auto pipelineResult = mPipelineCache->GetPipeline(queryInfo, true);
 
+  mPipeline = pipelineResult.level2;
+
   // should be never null?
   return *pipelineResult.pipeline;
 }