Add CanvasView thread rasterization

[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / controls / canvas-view / canvas-view-impl.cpp

diff --git a/dali-toolkit/internal/controls/canvas-view/canvas-view-impl.cpp b/dali-toolkit/internal/controls/canvas-view/canvas-view-impl.cpp
index 07c77d9..0132e3c 100644 (file)
--- a/dali-toolkit/internal/controls/canvas-view/canvas-view-impl.cpp
+++ b/dali-toolkit/internal/controls/canvas-view/canvas-view-impl.cpp
@@ -25,8 +25,8 @@
 #include <dali/public-api/object/type-registry.h>
 
 // INTERNAL INCLUDES
-#include <dali-toolkit/devel-api/controls/canvas-view/canvas-view.h>
 #include <dali-toolkit/devel-api/controls/control-devel.h>
+#include <dali-toolkit/internal/controls/canvas-view/canvas-view-rasterize-thread.h>
 #include <dali-toolkit/internal/controls/control/control-data-impl.h>
 #include <dali-toolkit/internal/graphics/builtin-shader-extern-gen.h>
 #include <dali-toolkit/internal/visuals/visual-factory-cache.h>
@@ -54,12 +54,21 @@ CanvasView::CanvasView(const Vector2& viewBox)
 : Control(ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT)),
   mCanvasRenderer(CanvasRenderer::New(viewBox)),
   mTexture(),
-  mChanged(false)
+  mTextureSet(),
+  mSize(viewBox),
+  mCanvasViewRasterizeThread(nullptr)
 {
 }
 
 CanvasView::~CanvasView()
 {
+  if(mCanvasViewRasterizeThread)
+  {
+    mCanvasViewRasterizeThread->RemoveTask(this);
+
+    CanvasViewRasterizeThread::TerminateThread(mCanvasViewRasterizeThread);
+  }
+
   if(Adaptor::IsAvailable())
   {
     Adaptor::Get().UnregisterProcessor(*this);
@@ -91,20 +100,17 @@ void CanvasView::OnInitialize()
       new DevelControl::AccessibleImpl(actor, Dali::Accessibility::Role::IMAGE));
   });
 
-  Self().SetProperty(Toolkit::DevelControl::Property::ACCESSIBILITY_HIGHLIGHTABLE, true);
-
   Adaptor::Get().RegisterProcessor(*this);
 }
 
 void CanvasView::OnRelayout(const Vector2& size, RelayoutContainer& container)
 {
   if(!mCanvasRenderer ||
-     mCanvasRenderer.GetSize() == size ||
      !mCanvasRenderer.SetSize(size))
   {
     return;
   }
-  mChanged = true;
+  mSize = size;
 }
 
 void CanvasView::OnSizeSet(const Vector3& targetSize)
@@ -112,58 +118,83 @@ void CanvasView::OnSizeSet(const Vector3& targetSize)
   Control::OnSizeSet(targetSize);
 
   if(!mCanvasRenderer ||
-     mCanvasRenderer.GetSize() == Vector2(targetSize) ||
      !mCanvasRenderer.SetSize(Vector2(targetSize)))
   {
     return;
   }
-  mChanged = true;
+  mSize.width  = targetSize.width;
+  mSize.height = targetSize.height;
 }
 
-void CanvasView::Process()
+void CanvasView::Process(bool postProcessor)
 {
-  if(!mCanvasRenderer)
+  if(mCanvasRenderer && mCanvasRenderer.IsCanvasChanged() && mSize.width > 0 && mSize.height > 0)
   {
-    return;
+    AddRasterizationTask();
   }
-  Commit();
 }
 
-void CanvasView::Commit()
+void CanvasView::AddRasterizationTask()
 {
-  if(mCanvasRenderer && mCanvasRenderer.Commit())
+  CanvasRendererRasterizingTaskPtr newTask = new CanvasRendererRasterizingTask(this, mCanvasRenderer);
+
+  if(!mCanvasViewRasterizeThread)
   {
-    Devel::PixelBuffer pixbuf = mCanvasRenderer.GetPixelBuffer();
-    auto               width  = pixbuf.GetWidth();
-    auto               height = pixbuf.GetHeight();
+    mCanvasViewRasterizeThread = new CanvasViewRasterizeThread();
+    mCanvasViewRasterizeThread->RasterizationCompletedSignal().Connect(this, &CanvasView::ApplyRasterizedImage);
+    mCanvasViewRasterizeThread->Start();
+  }
 
-    Dali::PixelData pixelData = Devel::PixelBuffer::Convert(pixbuf);
-    if(!pixelData)
-    {
-      return;
-    }
+  if(mCanvasRenderer.Commit())
+  {
+    mCanvasViewRasterizeThread->AddTask(newTask);
+  }
+}
 
-    if(!mTexture || mChanged)
-    {
-      mTexture = Texture::New(TextureType::TEXTURE_2D, Dali::Pixel::RGBA8888, width, height);
-      mTexture.Upload(pixelData);
-      TextureSet textureSet = TextureSet::New();
-      textureSet.SetTexture(0, mTexture);
-      Geometry geometry = VisualFactoryCache::CreateQuadGeometry();
-      Shader   shader   = Shader::New(SHADER_CANVAS_VIEW_VERT, SHADER_CANVAS_VIEW_FRAG);
-      Renderer renderer = Renderer::New(geometry, shader);
-      renderer.SetTextures(textureSet);
-      renderer.SetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, true);
-
-      Self().AddRenderer(renderer);
-      mChanged = false;
-    }
-    else
+void CanvasView::ApplyRasterizedImage(PixelData rasterizedPixelData)
+{
+  if(rasterizedPixelData)
+  {
+    auto rasterizedPixelDataWidth  = rasterizedPixelData.GetWidth();
+    auto rasterizedPixelDataHeight = rasterizedPixelData.GetHeight();
+
+    if(rasterizedPixelDataWidth > 0 && rasterizedPixelDataHeight > 0)
     {
-      //Update texture
-      mTexture.Upload(pixelData);
+      if(!mTexture || mTexture.GetWidth() != rasterizedPixelDataWidth || mTexture.GetHeight() != rasterizedPixelDataHeight)
+      {
+        mTexture = Texture::New(TextureType::TEXTURE_2D, Dali::Pixel::RGBA8888, rasterizedPixelDataWidth, rasterizedPixelDataHeight);
+        mTexture.Upload(rasterizedPixelData);
+
+        if(!mTextureSet)
+        {
+          mTextureSet       = TextureSet::New();
+          Geometry geometry = VisualFactoryCache::CreateQuadGeometry();
+          Shader   shader   = Shader::New(SHADER_CANVAS_VIEW_VERT, SHADER_CANVAS_VIEW_FRAG);
+          Renderer renderer = Renderer::New(geometry, shader);
+          renderer.SetTextures(mTextureSet);
+          renderer.SetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, true);
+
+          Actor actor = Self();
+          if(actor)
+          {
+            actor.AddRenderer(renderer);
+          }
+        }
+        mTextureSet.SetTexture(0, mTexture);
+      }
+      else
+      {
+        //Update texture
+        mTexture.Upload(rasterizedPixelData);
+      }
     }
   }
+
+  //If there are accumulated changes to CanvasRenderer during Rasterize, Rasterize once again.
+  if(mCanvasRenderer && mCanvasRenderer.IsCanvasChanged())
+  {
+    AddRasterizationTask();
+  }
 }
 
 bool CanvasView::AddDrawable(Dali::CanvasRenderer::Drawable& drawable)