#include <dali/public-api/object/type-registry.h>
// INTERNAL INCLUDES
-#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/imaging/common/pixel-buffer-impl.h>
+#include <dali/internal/canvas-renderer/common/gradient-impl.h>
+#include <dali/internal/canvas-renderer/common/shape-impl.h>
namespace Dali
{
}
CanvasRendererTizen::CanvasRendererTizen(const Vector2& viewBox)
-: mPixelBuffer(nullptr),
+:
#ifdef THORVG_SUPPORT
+ mRasterizedTexture(),
+ mMutex(),
mTvgCanvas(nullptr),
mTvgRoot(nullptr),
+ mNativeImageQueue(nullptr),
#endif
mSize(Vector2::ZERO),
mViewBox(Vector2::ZERO),
}
else
{
- if(!mPixelBuffer || !mPixelBuffer.GetBuffer())
- {
- MakeTargetBuffer(mSize);
- mChanged = false;
- }
+ MakeTargetBuffer(mSize);
+ mChanged = false;
}
if(mTvgCanvas->clear() != tvg::Result::Success)
#endif
}
-Devel::PixelBuffer CanvasRendererTizen::GetPixelBuffer()
+Dali::Texture CanvasRendererTizen::GetRasterizedTexture()
{
- return mPixelBuffer;
+#ifdef THORVG_SUPPORT
+ if(mNativeImageQueue)
+ {
+ if(!mRasterizedTexture)
+ {
+ mRasterizedTexture = Dali::Texture::New(*mNativeImageQueue);
+ }
+ return mRasterizedTexture;
+ }
+ else
+ {
+ return Dali::Texture();
+ }
+#else
+ return Dali::Texture();
+#endif
}
bool CanvasRendererTizen::AddDrawable(Dali::CanvasRenderer::Drawable& drawable)
{
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)
{
}
}
}
+ 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;
}
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);
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
#ifdef THORVG_SUPPORT
Mutex::ScopedLock lock(mMutex);
- if(mTvgCanvas->draw() != tvg::Result::Success)
+ if(mNativeImageQueue && mNativeImageQueue->CanDequeueBuffer())
+ {
+ uint32_t width, height, stride;
+ uint8_t* buffer = mNativeImageQueue->DequeueBuffer(width, height, stride);
+ if(!buffer)
+ {
+ DALI_LOG_ERROR("Pixel buffer create to fail [%p]\n", this);
+ return false;
+ }
+
+ mTvgCanvas->target(reinterpret_cast<uint32_t*>(buffer), stride / 4, width, height, tvg::SwCanvas::ARGB8888);
+
+ if(mTvgCanvas->draw() != tvg::Result::Success)
+ {
+ DALI_LOG_ERROR("ThorVG Draw fail [%p]\n", this);
+ mNativeImageQueue->EnqueueBuffer(buffer);
+ return false;
+ }
+
+ mTvgCanvas->sync();
+
+ mNativeImageQueue->EnqueueBuffer(buffer);
+ }
+ else
{
- DALI_LOG_ERROR("ThorVG Draw fail [%p]\n", this);
return false;
}
- mTvgCanvas->sync();
+ return true;
+#else
+ return false;
+#endif
+}
+
+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
#endif
}
-bool CanvasRendererTizen::SetSize(const Vector2& size)
+bool CanvasRendererTizen::SetSize(Vector2 size)
{
if(size.width < 1.0f || size.height < 1.0f)
{
return true;
}
-const Vector2& CanvasRendererTizen::GetSize()
+Vector2 CanvasRendererTizen::GetSize() const
{
return mSize;
}
void CanvasRendererTizen::MakeTargetBuffer(const Vector2& size)
{
#ifdef THORVG_SUPPORT
- mPixelBuffer = Devel::PixelBuffer::New(size.width, size.height, Dali::Pixel::RGBA8888);
-
- unsigned char* pBuffer;
- pBuffer = mPixelBuffer.GetBuffer();
-
- if(!pBuffer)
+ if(!mNativeImageQueue)
{
- DALI_LOG_ERROR("Pixel buffer create to fail [%p]\n", this);
- return;
+ mNativeImageQueue = Dali::NativeImageSourceQueue::New(size.width, size.height, Dali::NativeImageSourceQueue::ColorFormat::RGBA8888);
+ }
+ else
+ {
+ mNativeImageQueue->SetSize(static_cast<uint32_t>(size.width), static_cast<uint32_t>(size.height));
}
-
- mTvgCanvas->target(reinterpret_cast<uint32_t*>(pBuffer), size.width, size.width, size.height, tvg::SwCanvas::ABGR8888);
#endif
}
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))