dali/internal/canvas-renderer/tizen/canvas-renderer-impl-tizen.cpp

   1 /*
   2  * Copyright (c) 2021 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include <dali/internal/canvas-renderer/tizen/canvas-renderer-impl-tizen.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/integration-api/debug.h>
  23 #include <dali/public-api/object/type-registry.h>
  24
  25 // INTERNAL INCLUDES
  26 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
  27 #include <dali/internal/canvas-renderer/common/drawable-group-impl.h>
  28 #include <dali/internal/canvas-renderer/common/drawable-impl.h>
  29 #include <dali/internal/imaging/common/pixel-buffer-impl.h>
  30
  31 namespace Dali
  32 {
  33 namespace Internal
  34 {
  35 namespace Adaptor
  36 {
  37 namespace // unnamed namespace
  38 {
  39 // Type Registration
  40 Dali::BaseHandle Create()
  41 {
  42   return Dali::BaseHandle();
  43 }
  44
  45 Dali::TypeRegistration type(typeid(Dali::CanvasRenderer), typeid(Dali::BaseHandle), Create);
  46
  47 } // unnamed namespace
  48
  49 CanvasRendererTizen* CanvasRendererTizen::New(const Vector2& viewBox)
  50 {
  51   return new CanvasRendererTizen(viewBox);
  52 }
  53
  54 CanvasRendererTizen::CanvasRendererTizen(const Vector2& viewBox)
  55 : mPixelBuffer(nullptr),
  56 #ifdef THORVG_SUPPORT
  57   mTvgCanvas(nullptr),
  58   mTvgRoot(nullptr),
  59 #endif
  60   mSize(Vector2::ZERO),
  61   mViewBox(Vector2::ZERO),
  62   mChanged(false)
  63 {
  64   Initialize(viewBox);
  65 }
  66
  67 CanvasRendererTizen::~CanvasRendererTizen()
  68 {
  69 #ifdef THORVG_SUPPORT
  70   mDrawables.clear();
  71
  72   //Terminate ThorVG Engine
  73   tvg::Initializer::term(tvg::CanvasEngine::Sw);
  74 #endif
  75 }
  76
  77 void CanvasRendererTizen::Initialize(const Vector2& viewBox)
  78 {
  79 #ifdef THORVG_SUPPORT
  80   if(tvg::Initializer::init(tvg::CanvasEngine::Sw, 0 /*threads*/) != tvg::Result::Success)
  81   {
  82     DALI_LOG_ERROR("ThorVG engine initialize failed\n");
  83   }
  84   mTvgCanvas = tvg::SwCanvas::gen();
  85
  86   mSize = mViewBox = viewBox;
  87   if(viewBox.width < 1.0f || viewBox.height < 1.0f)
  88   {
  89     return;
  90   }
  91
  92   MakeTargetBuffer(mSize);
  93 #endif
  94 }
  95
  96 bool CanvasRendererTizen::Commit()
  97 {
  98 #ifdef THORVG_SUPPORT
  99   Mutex::ScopedLock lock(mMutex);
 100
 101   if(mSize.width < 1.0f || mSize.height < 1.0f)
 102   {
 103     DALI_LOG_ERROR("Size is zero [%p]\n", this);
 104     return false;
 105   }
 106
 107   bool changed = false;
 108
 109   for(auto& it : mDrawables)
 110   {
 111     if(HaveDrawablesChanged(it))
 112     {
 113       UpdateDrawablesChanged(it, false);
 114       changed = true;
 115     }
 116   }
 117
 118   if(!changed && !mChanged)
 119   {
 120     return false;
 121   }
 122   else
 123   {
 124     if(!mPixelBuffer || !mPixelBuffer.GetBuffer())
 125     {
 126       MakeTargetBuffer(mSize);
 127       mChanged = false;
 128     }
 129   }
 130
 131   if(mTvgCanvas->clear() != tvg::Result::Success)
 132   {
 133     DALI_LOG_ERROR("ThorVG canvas clear fail [%p]\n", this);
 134     return false;
 135   }
 136
 137   auto scene = tvg::Scene::gen();
 138   mTvgRoot   = scene.get();
 139   for(auto& it : mDrawables)
 140   {
 141     PushDrawableToGroup(it, mTvgRoot);
 142   }
 143
 144   if(mViewBox != mSize && mViewBox.width > 0 && mViewBox.height > 0)
 145   {
 146     auto scaleX = mSize.width / mViewBox.width;
 147     auto scaleY = mSize.height / mViewBox.height;
 148     mTvgRoot->scale(scaleX < scaleY ? scaleX : scaleY);
 149   }
 150
 151   if(mTvgCanvas->push(move(scene)) != tvg::Result::Success)
 152   {
 153     DALI_LOG_ERROR("ThorVG canvas push fail [%p]\n", this);
 154     return false;
 155   }
 156
 157   return true;
 158 #else
 159   return false;
 160 #endif
 161 }
 162
 163 Devel::PixelBuffer CanvasRendererTizen::GetPixelBuffer()
 164 {
 165   return mPixelBuffer;
 166 }
 167
 168 bool CanvasRendererTizen::AddDrawable(Dali::CanvasRenderer::Drawable& drawable)
 169 {
 170 #ifdef THORVG_SUPPORT
 171   Internal::Adaptor::Drawable& drawableImpl = GetImplementation(drawable);
 172   if(drawableImpl.IsAdded())
 173   {
 174     DALI_LOG_ERROR("Already added [%p][%p]\n", this, &drawable);
 175     return false;
 176   }
 177
 178   drawableImpl.SetAdded(true);
 179   mDrawables.push_back(drawable);
 180   mChanged = true;
 181
 182   return true;
 183 #else
 184   return false;
 185 #endif
 186 }
 187
 188 #ifdef THORVG_SUPPORT
 189 bool CanvasRendererTizen::HaveDrawablesChanged(const Dali::CanvasRenderer::Drawable& drawable) const
 190 {
 191   const Internal::Adaptor::Drawable& drawableImpl = GetImplementation(drawable);
 192   if(drawableImpl.GetChanged())
 193   {
 194     return true;
 195   }
 196   Dali::CanvasRenderer::Drawable compositeDrawable = drawableImpl.GetCompositionDrawable();
 197   if(DALI_UNLIKELY(compositeDrawable))
 198   {
 199     Internal::Adaptor::Drawable& compositeDrawableImpl = Dali::GetImplementation(compositeDrawable);
 200     if(compositeDrawableImpl.GetChanged())
 201     {
 202       return true;
 203     }
 204   }
 205
 206   if(drawableImpl.GetType() == Drawable::Types::DRAWABLE_GROUP)
 207   {
 208     const Dali::CanvasRenderer::DrawableGroup& group             = static_cast<const Dali::CanvasRenderer::DrawableGroup&>(drawable);
 209     const Internal::Adaptor::DrawableGroup&    drawableGroupImpl = Dali::GetImplementation(group);
 210     DrawableGroup::DrawableVector              drawables         = drawableGroupImpl.GetDrawables();
 211     for(auto& it : drawables)
 212     {
 213       if(HaveDrawablesChanged(it))
 214       {
 215         return true;
 216       }
 217     }
 218   }
 219
 220   return false;
 221 }
 222
 223 void CanvasRendererTizen::UpdateDrawablesChanged(Dali::CanvasRenderer::Drawable& drawable, bool changed)
 224 {
 225   Internal::Adaptor::Drawable& drawableImpl = GetImplementation(drawable);
 226   drawableImpl.SetChanged(changed);
 227
 228   Dali::CanvasRenderer::Drawable compositeDrawable = drawableImpl.GetCompositionDrawable();
 229   if(DALI_UNLIKELY(compositeDrawable))
 230   {
 231     Internal::Adaptor::Drawable& compositeDrawableImpl = Dali::GetImplementation(compositeDrawable);
 232     compositeDrawableImpl.SetChanged(changed);
 233   }
 234
 235   if(drawableImpl.GetType() == Drawable::Types::DRAWABLE_GROUP)
 236   {
 237     Dali::CanvasRenderer::DrawableGroup& group             = static_cast<Dali::CanvasRenderer::DrawableGroup&>(drawable);
 238     Internal::Adaptor::DrawableGroup&    drawableGroupImpl = Dali::GetImplementation(group);
 239     DrawableGroup::DrawableVector        drawables         = drawableGroupImpl.GetDrawables();
 240     for(auto& it : drawables)
 241     {
 242       UpdateDrawablesChanged(it, changed);
 243     }
 244   }
 245 }
 246 #endif
 247
 248 bool CanvasRendererTizen::IsCanvasChanged() const
 249 {
 250 #ifdef THORVG_SUPPORT
 251   if(mChanged)
 252   {
 253     return true;
 254   }
 255
 256   for(auto& it : mDrawables)
 257   {
 258     if(HaveDrawablesChanged(it))
 259     {
 260       return true;
 261     }
 262   }
 263 #endif
 264   return false;
 265 }
 266
 267 bool CanvasRendererTizen::Rasterize()
 268 {
 269 #ifdef THORVG_SUPPORT
 270   Mutex::ScopedLock lock(mMutex);
 271
 272   if(mTvgCanvas->draw() != tvg::Result::Success)
 273   {
 274     DALI_LOG_ERROR("ThorVG Draw fail [%p]\n", this);
 275     return false;
 276   }
 277
 278   mTvgCanvas->sync();
 279
 280   return true;
 281 #else
 282   return false;
 283 #endif
 284 }
 285
 286 bool CanvasRendererTizen::RemoveDrawable(Dali::CanvasRenderer::Drawable& drawable)
 287 {
 288 #ifdef THORVG_SUPPORT
 289   DrawableGroup::DrawableVector::iterator it = std::find(mDrawables.begin(), mDrawables.end(), drawable);
 290   if(it != mDrawables.end())
 291   {
 292     Internal::Adaptor::Drawable& drawableImpl = GetImplementation(drawable);
 293     drawableImpl.SetAdded(false);
 294
 295     mDrawables.erase(it);
 296     mChanged = true;
 297
 298     return true;
 299   }
 300
 301 #endif
 302   return false;
 303 }
 304
 305 bool CanvasRendererTizen::RemoveAllDrawables()
 306 {
 307 #ifdef THORVG_SUPPORT
 308   for(auto& it : mDrawables)
 309   {
 310     Internal::Adaptor::Drawable& drawableImpl = GetImplementation(it);
 311     drawableImpl.SetAdded(false);
 312   }
 313
 314   mDrawables.clear();
 315   mChanged = true;
 316
 317   return true;
 318 #else
 319   return false;
 320 #endif
 321 }
 322
 323 bool CanvasRendererTizen::SetSize(Vector2 size)
 324 {
 325   if(size.width < 1.0f || size.height < 1.0f)
 326   {
 327     return false;
 328   }
 329
 330   if(size != mSize)
 331   {
 332     mSize    = size;
 333     mChanged = true;
 334   }
 335
 336   return true;
 337 }
 338
 339 Vector2 CanvasRendererTizen::GetSize() const
 340 {
 341   return mSize;
 342 }
 343
 344 bool CanvasRendererTizen::SetViewBox(const Vector2& viewBox)
 345 {
 346   if(viewBox.width < 1.0f || viewBox.height < 1.0f)
 347   {
 348     return false;
 349   }
 350
 351   if(viewBox != mViewBox)
 352   {
 353     mViewBox = viewBox;
 354     mChanged = true;
 355   }
 356
 357   return true;
 358 }
 359
 360 const Vector2& CanvasRendererTizen::GetViewBox()
 361 {
 362   return mViewBox;
 363 }
 364
 365 void CanvasRendererTizen::MakeTargetBuffer(const Vector2& size)
 366 {
 367 #ifdef THORVG_SUPPORT
 368   mPixelBuffer = Devel::PixelBuffer::New(size.width, size.height, Dali::Pixel::RGBA8888);
 369
 370   unsigned char* pBuffer;
 371   pBuffer = mPixelBuffer.GetBuffer();
 372
 373   if(!pBuffer)
 374   {
 375     DALI_LOG_ERROR("Pixel buffer create to fail [%p]\n", this);
 376     return;
 377   }
 378
 379   mTvgCanvas->target(reinterpret_cast<uint32_t*>(pBuffer), size.width, size.width, size.height, tvg::SwCanvas::ABGR8888);
 380 #endif
 381 }
 382
 383 #ifdef THORVG_SUPPORT
 384 void CanvasRendererTizen::PushDrawableToGroup(Dali::CanvasRenderer::Drawable& drawable, tvg::Scene* parent)
 385 {
 386   Internal::Adaptor::Drawable& drawableImpl        = Dali::GetImplementation(drawable);
 387   tvg::Paint*                  tvgDuplicatedObject = static_cast<tvg::Paint*>(drawableImpl.GetObject())->duplicate();
 388   if(!tvgDuplicatedObject)
 389   {
 390     DALI_LOG_ERROR("Invalid drawable object [%p]\n", this);
 391     return;
 392   }
 393   Drawable::Types type = drawableImpl.GetType();
 394
 395   if(type == Drawable::Types::DRAWABLE_GROUP)
 396   {
 397     Dali::CanvasRenderer::DrawableGroup& group             = static_cast<Dali::CanvasRenderer::DrawableGroup&>(drawable);
 398     Internal::Adaptor::DrawableGroup&    drawableGroupImpl = Dali::GetImplementation(group);
 399     DrawableGroup::DrawableVector        drawables         = drawableGroupImpl.GetDrawables();
 400     for(auto& it : drawables)
 401     {
 402       PushDrawableToGroup(it, static_cast<tvg::Scene*>(tvgDuplicatedObject));
 403     }
 404   }
 405
 406   Dali::CanvasRenderer::Drawable compositeDrawable = drawableImpl.GetCompositionDrawable();
 407   if(DALI_UNLIKELY(compositeDrawable))
 408   {
 409     Internal::Adaptor::Drawable& compositeDrawableImpl = Dali::GetImplementation(compositeDrawable);
 410     tvg::Paint*                  tvgCompositeObject    = static_cast<tvg::Paint*>(compositeDrawableImpl.GetObject());
 411     if(tvgCompositeObject)
 412     {
 413       tvg::Paint*     tvgDuplicatedCompositeObject = tvgCompositeObject->duplicate();
 414       Drawable::Types type                         = compositeDrawableImpl.GetType();
 415
 416       if(type == Drawable::Types::DRAWABLE_GROUP)
 417       {
 418         Dali::CanvasRenderer::DrawableGroup& compositeGroup             = static_cast<Dali::CanvasRenderer::DrawableGroup&>(compositeDrawable);
 419         Internal::Adaptor::DrawableGroup&    compositeDrawableGroupImpl = Dali::GetImplementation(compositeGroup);
 420         DrawableGroup::DrawableVector        compositeDrawables         = compositeDrawableGroupImpl.GetDrawables();
 421         for(auto& it : compositeDrawables)
 422         {
 423           PushDrawableToGroup(it, static_cast<tvg::Scene*>(tvgDuplicatedCompositeObject));
 424         }
 425       }
 426
 427       if(tvgDuplicatedObject->composite(std::move(std::unique_ptr<tvg::Paint>(tvgDuplicatedCompositeObject)), static_cast<tvg::CompositeMethod>(drawableImpl.GetCompositionType())) != tvg::Result::Success)
 428       {
 429         DALI_LOG_ERROR("Tvg composite fail [%p]\n", this);
 430         return;
 431       }
 432     }
 433   }
 434
 435   if(parent->push(std::move(std::unique_ptr<tvg::Paint>(tvgDuplicatedObject))) != tvg::Result::Success)
 436   {
 437     DALI_LOG_ERROR("Tvg push fail [%p]\n", this);
 438     return;
 439   }
 440 }
 441 #endif
 442
 443 } // namespace Adaptor
 444
 445 } // namespace Internal
 446
 447 } // namespace Dali