dali-toolkit/internal/controls/canvas-view/canvas-view-impl.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 "canvas-view-impl.h"
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/devel-api/scripting/scripting.h>
  23 #include <dali/integration-api/adaptor-framework/adaptor.h>
  24 #include <dali/public-api/object/type-registry-helper.h>
  25 #include <dali/public-api/object/type-registry.h>
  26 #include <dali/devel-api/rendering/texture-devel.h>
  27
  28 // INTERNAL INCLUDES
  29 #include <dali-toolkit/devel-api/controls/control-devel.h>
  30 #include <dali-toolkit/internal/controls/canvas-view/canvas-view-rasterize-thread.h>
  31 #include <dali-toolkit/internal/controls/control/control-data-impl.h>
  32 #include <dali-toolkit/internal/graphics/builtin-shader-extern-gen.h>
  33 #include <dali-toolkit/internal/visuals/visual-factory-cache.h>
  34
  35 namespace Dali
  36 {
  37 namespace Toolkit
  38 {
  39 namespace Internal
  40 {
  41 namespace
  42 {
  43 BaseHandle Create()
  44 {
  45   return BaseHandle();
  46 }
  47 // Setup properties, signals and actions using the type-registry.
  48 DALI_TYPE_REGISTRATION_BEGIN(Toolkit::CanvasView, Toolkit::Control, Create);
  49 DALI_PROPERTY_REGISTRATION(Toolkit, CanvasView, "viewBox", VECTOR2, VIEW_BOX)
  50 DALI_TYPE_REGISTRATION_END()
  51 } // anonymous namespace
  52
  53 using namespace Dali;
  54
  55 CanvasView::CanvasView(const Vector2& viewBox)
  56 : Control(ControlBehaviour(CONTROL_BEHAVIOUR_DEFAULT)),
  57   mCanvasRenderer(CanvasRenderer::New(viewBox)),
  58   mTexture(),
  59   mTextureSet(),
  60   mSize(viewBox),
  61   mCanvasViewRasterizeThread(nullptr)
  62 {
  63 }
  64
  65 CanvasView::~CanvasView()
  66 {
  67   if(mCanvasViewRasterizeThread)
  68   {
  69     mCanvasViewRasterizeThread->RemoveTask(this);
  70
  71     CanvasViewRasterizeThread::TerminateThread(mCanvasViewRasterizeThread);
  72   }
  73
  74   if(Adaptor::IsAvailable())
  75   {
  76     Adaptor::Get().UnregisterProcessor(*this);
  77   }
  78 }
  79
  80 Toolkit::CanvasView CanvasView::New(const Vector2& viewBox)
  81 {
  82   CanvasView* impl = new CanvasView(viewBox);
  83
  84   Toolkit::CanvasView handle = Toolkit::CanvasView(*impl);
  85
  86   // Second-phase init of the implementation
  87   // This can only be done after the CustomActor connection has been made...
  88   impl->Initialize();
  89
  90   return handle;
  91 }
  92
  93 /////////////////////////////////////////////////////////////
  94
  95 void CanvasView::OnInitialize()
  96 {
  97   // CanvasView can relayout in the OnImageReady, alternative to a signal would be to have a upcall from the Control to CanvasView
  98   Dali::Toolkit::Control handle(GetOwner());
  99
 100   DevelControl::SetAccessibilityConstructor(Self(), [](Dali::Actor actor) {
 101     return std::make_unique<DevelControl::ControlAccessible>(actor, Dali::Accessibility::Role::IMAGE);
 102   });
 103
 104   Adaptor::Get().RegisterProcessor(*this, true);
 105 }
 106
 107 void CanvasView::OnRelayout(const Vector2& size, RelayoutContainer& container)
 108 {
 109   if(!mCanvasRenderer ||
 110      !mCanvasRenderer.SetSize(size))
 111   {
 112     return;
 113   }
 114   mSize = size;
 115 }
 116
 117 void CanvasView::OnSizeSet(const Vector3& targetSize)
 118 {
 119   Control::OnSizeSet(targetSize);
 120
 121   if(!mCanvasRenderer ||
 122      !mCanvasRenderer.SetSize(Vector2(targetSize)))
 123   {
 124     return;
 125   }
 126   mSize.width  = targetSize.width;
 127   mSize.height = targetSize.height;
 128 }
 129
 130 void CanvasView::SetProperty(BaseObject* object, Property::Index propertyIndex, const Property::Value& value)
 131 {
 132   Toolkit::CanvasView canvasView = Toolkit::CanvasView::DownCast(Dali::BaseHandle(object));
 133   if(canvasView)
 134   {
 135     CanvasView& canvasViewImpl(GetImpl(canvasView));
 136
 137     switch(propertyIndex)
 138     {
 139       case Toolkit::CanvasView::Property::VIEW_BOX:
 140       {
 141         Vector2 valueVector2;
 142         if(value.Get(valueVector2))
 143         {
 144           canvasViewImpl.SetViewBox(valueVector2);
 145         }
 146         break;
 147       }
 148     }
 149   }
 150 }
 151
 152 Property::Value CanvasView::GetProperty(BaseObject* object, Property::Index propertyIndex)
 153 {
 154   Property::Value value;
 155
 156   Toolkit::CanvasView canvasView = Toolkit::CanvasView::DownCast(Dali::BaseHandle(object));
 157
 158   if(canvasView)
 159   {
 160     CanvasView& canvasViewImpl(GetImpl(canvasView));
 161
 162     switch(propertyIndex)
 163     {
 164       case Toolkit::CanvasView::Property::VIEW_BOX:
 165       {
 166         value = canvasViewImpl.GetViewBox();
 167         break;
 168       }
 169     }
 170   }
 171   return value;
 172 }
 173
 174 void CanvasView::Process(bool postProcessor)
 175 {
 176   if(mCanvasRenderer && mCanvasRenderer.IsCanvasChanged() && mSize.width > 0 && mSize.height > 0)
 177   {
 178     AddRasterizationTask();
 179   }
 180 }
 181
 182 void CanvasView::AddRasterizationTask()
 183 {
 184   CanvasRendererRasterizingTaskPtr newTask = new CanvasRendererRasterizingTask(this, mCanvasRenderer);
 185
 186   if(!mCanvasViewRasterizeThread)
 187   {
 188     mCanvasViewRasterizeThread = new CanvasViewRasterizeThread();
 189     mCanvasViewRasterizeThread->RasterizationCompletedSignal().Connect(this, &CanvasView::ApplyRasterizedImage);
 190     mCanvasViewRasterizeThread->Start();
 191   }
 192
 193   if(mCanvasRenderer.Commit())
 194   {
 195     mCanvasViewRasterizeThread->AddTask(newTask);
 196   }
 197 }
 198
 199 void CanvasView::ApplyRasterizedImage(Texture rasterizedTexture)
 200 {
 201   if (rasterizedTexture && rasterizedTexture.GetWidth() != 0 && rasterizedTexture.GetHeight() != 0)
 202   {
 203     if(!mTextureSet)
 204     {
 205       std::string fragmentShader = SHADER_CANVAS_VIEW_FRAG.data();
 206       DevelTexture::ApplyNativeFragmentShader(rasterizedTexture, fragmentShader);
 207
 208       mTextureSet       = TextureSet::New();
 209       Geometry geometry = VisualFactoryCache::CreateQuadGeometry();
 210       Shader   shader   = Shader::New(SHADER_CANVAS_VIEW_VERT, fragmentShader);
 211       Renderer renderer = Renderer::New(geometry, shader);
 212
 213       renderer.SetTextures(mTextureSet);
 214       renderer.SetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, true);
 215       Self().AddRenderer(renderer);
 216     }
 217     mTextureSet.SetTexture(0, rasterizedTexture);
 218   }
 219
 220   //If there are accumulated changes to CanvasRenderer during Rasterize, Rasterize once again.
 221   if(mCanvasRenderer && mCanvasRenderer.IsCanvasChanged())
 222   {
 223     AddRasterizationTask();
 224   }
 225 }
 226
 227 bool CanvasView::AddDrawable(Dali::CanvasRenderer::Drawable& drawable)
 228 {
 229   if(mCanvasRenderer && mCanvasRenderer.AddDrawable(drawable))
 230   {
 231     return true;
 232   }
 233   return false;
 234 }
 235
 236 bool CanvasView::RemoveDrawable(Dali::CanvasRenderer::Drawable& drawable)
 237 {
 238   if(mCanvasRenderer && mCanvasRenderer.RemoveDrawable(drawable))
 239   {
 240     return true;
 241   }
 242   return false;
 243 }
 244
 245 bool CanvasView::RemoveAllDrawables()
 246 {
 247   if(mCanvasRenderer && mCanvasRenderer.RemoveAllDrawables())
 248   {
 249     return true;
 250   }
 251   return false;
 252 }
 253
 254 bool CanvasView::SetViewBox(const Vector2& viewBox)
 255 {
 256   if(mCanvasRenderer && mCanvasRenderer.SetViewBox(viewBox))
 257   {
 258     return true;
 259   }
 260   return false;
 261 }
 262
 263 const Vector2& CanvasView::GetViewBox()
 264 {
 265   if(mCanvasRenderer)
 266   {
 267     return mCanvasRenderer.GetViewBox();
 268   }
 269   return Vector2::ZERO;
 270 }
 271 } // namespace Internal
 272 } // namespace Toolkit
 273 } // namespace Dali