CanvasRenderer: Refactoring to pass rasterized buffer

[platform/core/uifw/dali-adaptor.git] / dali / internal / canvas-renderer / tizen / canvas-renderer-impl-tizen.cpp

diff --git a/dali/internal/canvas-renderer/tizen/canvas-renderer-impl-tizen.cpp b/dali/internal/canvas-renderer/tizen/canvas-renderer-impl-tizen.cpp
index b38122e..bc45837 100644 (file)
--- a/dali/internal/canvas-renderer/tizen/canvas-renderer-impl-tizen.cpp
+++ b/dali/internal/canvas-renderer/tizen/canvas-renderer-impl-tizen.cpp
@@ -26,6 +26,8 @@
 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 #include <dali/internal/canvas-renderer/common/drawable-group-impl.h>
 #include <dali/internal/canvas-renderer/common/drawable-impl.h>
+#include <dali/internal/canvas-renderer/common/gradient-impl.h>
+#include <dali/internal/canvas-renderer/common/shape-impl.h>
 #include <dali/internal/imaging/common/pixel-buffer-impl.h>
 
 namespace Dali
@@ -52,13 +54,16 @@ CanvasRendererTizen* CanvasRendererTizen::New(const Vector2& viewBox)
 }
 
 CanvasRendererTizen::CanvasRendererTizen(const Vector2& viewBox)
-: mPixelBuffer(nullptr),
+:
 #ifdef THORVG_SUPPORT
+  mPixelBuffer(nullptr),
+  mRasterizedTexture(),
+  mMutex(),
   mTvgCanvas(nullptr),
   mTvgRoot(nullptr),
 #endif
-  mSize(0, 0),
-  mViewBox(0, 0),
+  mSize(Vector2::ZERO),
+  mViewBox(Vector2::ZERO),
   mChanged(false)
 {
   Initialize(viewBox);
@@ -160,9 +165,31 @@ bool CanvasRendererTizen::Commit()
 #endif
 }
 
-Devel::PixelBuffer CanvasRendererTizen::GetPixelBuffer()
+Dali::Texture CanvasRendererTizen::GetRasterizedTexture()
 {
-  return mPixelBuffer;
+#ifdef THORVG_SUPPORT
+  if(mPixelBuffer)
+  {
+    auto width  = mPixelBuffer.GetWidth();
+    auto height = mPixelBuffer.GetHeight();
+    if(width <= 0 || height <= 0)
+    {
+      return Dali::Texture();
+    }
+
+    Dali::PixelData pixelData = Devel::PixelBuffer::Convert(mPixelBuffer);
+
+    if(!mRasterizedTexture || mRasterizedTexture.GetWidth() != width || mRasterizedTexture.GetHeight() != height)
+    {
+      mRasterizedTexture = Dali::Texture::New(Dali::TextureType::TEXTURE_2D, Dali::Pixel::BGRA8888, width, height);
+    }
+
+    mRasterizedTexture.Upload(pixelData);
+  }
+  return mRasterizedTexture;
+#else
+  return Dali::Texture();
+#endif
 }
 
 bool CanvasRendererTizen::AddDrawable(Dali::CanvasRenderer::Drawable& drawable)
@@ -193,6 +220,15 @@ bool CanvasRendererTizen::HaveDrawablesChanged(const Dali::CanvasRenderer::Drawa
   {
     return true;
   }
+  Dali::CanvasRenderer::Drawable compositeDrawable = drawableImpl.GetCompositionDrawable();
+  if(DALI_UNLIKELY(compositeDrawable))
+  {
+    Internal::Adaptor::Drawable& compositeDrawableImpl = Dali::GetImplementation(compositeDrawable);
+    if(compositeDrawableImpl.GetChanged())
+    {
+      return true;
+    }
+  }
 
   if(drawableImpl.GetType() == Drawable::Types::DRAWABLE_GROUP)
   {
@@ -207,6 +243,29 @@ bool CanvasRendererTizen::HaveDrawablesChanged(const Dali::CanvasRenderer::Drawa
       }
     }
   }
+  else if(drawableImpl.GetType() == Drawable::Types::SHAPE)
+  {
+    const Dali::CanvasRenderer::Shape& shape        = static_cast<const Dali::CanvasRenderer::Shape&>(drawable);
+    Dali::CanvasRenderer::Gradient     fillGradient = shape.GetFillGradient();
+    if(DALI_UNLIKELY(fillGradient))
+    {
+      Internal::Adaptor::Gradient& fillGradientImpl = Dali::GetImplementation(fillGradient);
+      if(fillGradientImpl.GetChanged())
+      {
+        return true;
+      }
+    }
+
+    Dali::CanvasRenderer::Gradient strokeGradient = shape.GetStrokeGradient();
+    if(DALI_UNLIKELY(strokeGradient))
+    {
+      Internal::Adaptor::Gradient& strokeGradientImpl = Dali::GetImplementation(strokeGradient);
+      if(strokeGradientImpl.GetChanged())
+      {
+        return true;
+      }
+    }
+  }
 
   return false;
 }
@@ -216,6 +275,13 @@ void CanvasRendererTizen::UpdateDrawablesChanged(Dali::CanvasRenderer::Drawable&
   Internal::Adaptor::Drawable& drawableImpl = GetImplementation(drawable);
   drawableImpl.SetChanged(changed);
 
+  Dali::CanvasRenderer::Drawable compositeDrawable = drawableImpl.GetCompositionDrawable();
+  if(DALI_UNLIKELY(compositeDrawable))
+  {
+    Internal::Adaptor::Drawable& compositeDrawableImpl = Dali::GetImplementation(compositeDrawable);
+    compositeDrawableImpl.SetChanged(changed);
+  }
+
   if(drawableImpl.GetType() == Drawable::Types::DRAWABLE_GROUP)
   {
     Dali::CanvasRenderer::DrawableGroup& group             = static_cast<Dali::CanvasRenderer::DrawableGroup&>(drawable);
@@ -226,6 +292,23 @@ void CanvasRendererTizen::UpdateDrawablesChanged(Dali::CanvasRenderer::Drawable&
       UpdateDrawablesChanged(it, changed);
     }
   }
+  else if(drawableImpl.GetType() == Drawable::Types::SHAPE)
+  {
+    Dali::CanvasRenderer::Shape&   shape        = static_cast<Dali::CanvasRenderer::Shape&>(drawable);
+    Dali::CanvasRenderer::Gradient fillGradient = shape.GetFillGradient();
+    if(DALI_UNLIKELY(fillGradient))
+    {
+      Internal::Adaptor::Gradient& fillGradientImpl = Dali::GetImplementation(fillGradient);
+      fillGradientImpl.SetChanged(changed);
+    }
+
+    Dali::CanvasRenderer::Gradient strokeGradient = shape.GetStrokeGradient();
+    if(DALI_UNLIKELY(strokeGradient))
+    {
+      Internal::Adaptor::Gradient& strokeGradientImpl = Dali::GetImplementation(strokeGradient);
+      strokeGradientImpl.SetChanged(changed);
+    }
+  }
 }
 #endif
 
@@ -267,7 +350,44 @@ bool CanvasRendererTizen::Rasterize()
 #endif
 }
 
-bool CanvasRendererTizen::SetSize(const Vector2& size)
+bool CanvasRendererTizen::RemoveDrawable(Dali::CanvasRenderer::Drawable& drawable)
+{
+#ifdef THORVG_SUPPORT
+  DrawableGroup::DrawableVector::iterator it = std::find(mDrawables.begin(), mDrawables.end(), drawable);
+  if(it != mDrawables.end())
+  {
+    Internal::Adaptor::Drawable& drawableImpl = GetImplementation(drawable);
+    drawableImpl.SetAdded(false);
+
+    mDrawables.erase(it);
+    mChanged = true;
+
+    return true;
+  }
+
+#endif
+  return false;
+}
+
+bool CanvasRendererTizen::RemoveAllDrawables()
+{
+#ifdef THORVG_SUPPORT
+  for(auto& it : mDrawables)
+  {
+    Internal::Adaptor::Drawable& drawableImpl = GetImplementation(it);
+    drawableImpl.SetAdded(false);
+  }
+
+  mDrawables.clear();
+  mChanged = true;
+
+  return true;
+#else
+  return false;
+#endif
+}
+
+bool CanvasRendererTizen::SetSize(Vector2 size)
 {
   if(size.width < 1.0f || size.height < 1.0f)
   {
@@ -283,15 +403,36 @@ bool CanvasRendererTizen::SetSize(const Vector2& size)
   return true;
 }
 
-const Vector2& CanvasRendererTizen::GetSize()
+Vector2 CanvasRendererTizen::GetSize() const
 {
   return mSize;
 }
 
+bool CanvasRendererTizen::SetViewBox(const Vector2& viewBox)
+{
+  if(viewBox.width < 1.0f || viewBox.height < 1.0f)
+  {
+    return false;
+  }
+
+  if(viewBox != mViewBox)
+  {
+    mViewBox = viewBox;
+    mChanged = true;
+  }
+
+  return true;
+}
+
+const Vector2& CanvasRendererTizen::GetViewBox()
+{
+  return mViewBox;
+}
+
 void CanvasRendererTizen::MakeTargetBuffer(const Vector2& size)
 {
 #ifdef THORVG_SUPPORT
-  mPixelBuffer = Devel::PixelBuffer::New(size.width, size.height, Dali::Pixel::RGBA8888);
+  mPixelBuffer = Devel::PixelBuffer::New(size.width, size.height, Dali::Pixel::BGRA8888);
 
   unsigned char* pBuffer;
   pBuffer = mPixelBuffer.GetBuffer();
@@ -302,7 +443,7 @@ void CanvasRendererTizen::MakeTargetBuffer(const Vector2& size)
     return;
   }
 
-  mTvgCanvas->target(reinterpret_cast<uint32_t*>(pBuffer), size.width, size.width, size.height, tvg::SwCanvas::ABGR8888);
+  mTvgCanvas->target(reinterpret_cast<uint32_t*>(pBuffer), size.width, size.width, size.height, tvg::SwCanvas::ARGB8888);
 #endif
 }
 
@@ -328,6 +469,45 @@ void CanvasRendererTizen::PushDrawableToGroup(Dali::CanvasRenderer::Drawable& dr
       PushDrawableToGroup(it, static_cast<tvg::Scene*>(tvgDuplicatedObject));
     }
   }
+  else if(type == Drawable::Types::SHAPE)
+  {
+    //FillGradient
+    Dali::CanvasRenderer::Shape&   shape        = static_cast<Dali::CanvasRenderer::Shape&>(drawable);
+    Dali::CanvasRenderer::Gradient fillGradient = shape.GetFillGradient();
+    if(DALI_UNLIKELY(fillGradient))
+    {
+      Internal::Adaptor::Gradient& fillGradientImpl          = Dali::GetImplementation(fillGradient);
+      tvg::Fill*                   tvgDuplicatedFillGradient = static_cast<tvg::Fill*>(fillGradientImpl.GetObject())->duplicate();
+      if(!tvgDuplicatedFillGradient)
+      {
+        DALI_LOG_ERROR("Invalid gradient object [%p]\n", this);
+        return;
+      }
+      if(static_cast<tvg::Shape*>(tvgDuplicatedObject)->fill(std::unique_ptr<tvg::Fill>(tvgDuplicatedFillGradient)) != tvg::Result::Success)
+      {
+        DALI_LOG_ERROR("Tvg gradient set fail [%p]\n", this);
+        return;
+      }
+    }
+
+    //StrokeGradient
+    Dali::CanvasRenderer::Gradient strokeGradient = shape.GetStrokeGradient();
+    if(DALI_UNLIKELY(strokeGradient))
+    {
+      Internal::Adaptor::Gradient& strokeGradientImpl          = Dali::GetImplementation(strokeGradient);
+      tvg::Fill*                   tvgDuplicatedStrokeGradient = static_cast<tvg::Fill*>(strokeGradientImpl.GetObject())->duplicate();
+      if(!tvgDuplicatedStrokeGradient)
+      {
+        DALI_LOG_ERROR("Invalid gradient object [%p]\n", this);
+        return;
+      }
+      if(static_cast<tvg::Shape*>(tvgDuplicatedObject)->stroke(std::unique_ptr<tvg::Fill>(tvgDuplicatedStrokeGradient)) != tvg::Result::Success)
+      {
+        DALI_LOG_ERROR("Tvg gradient set fail [%p]\n", this);
+        return;
+      }
+    }
+  }
 
   Dali::CanvasRenderer::Drawable compositeDrawable = drawableImpl.GetCompositionDrawable();
   if(DALI_UNLIKELY(compositeDrawable))