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::unique_ptr<Dali::Accessibility::Accessible>(
 102       new DevelControl::AccessibleImpl(actor, Dali::Accessibility::Role::IMAGE));
 103   });
 104
 105   Adaptor::Get().RegisterProcessor(*this, true);
 106 }
 107
 108 void CanvasView::OnRelayout(const Vector2& size, RelayoutContainer& container)
 109 {
 110   if(!mCanvasRenderer ||
 111      !mCanvasRenderer.SetSize(size))
 112   {
 113     return;
 114   }
 115   mSize = size;
 116 }
 117
 118 void CanvasView::OnSizeSet(const Vector3& targetSize)
 119 {
 120   Control::OnSizeSet(targetSize);
 121
 122   if(!mCanvasRenderer ||
 123      !mCanvasRenderer.SetSize(Vector2(targetSize)))
 124   {
 125     return;
 126   }
 127   mSize.width  = targetSize.width;
 128   mSize.height = targetSize.height;
 129 }
 130
 131 void CanvasView::SetProperty(BaseObject* object, Property::Index propertyIndex, const Property::Value& value)
 132 {
 133   Toolkit::CanvasView canvasView = Toolkit::CanvasView::DownCast(Dali::BaseHandle(object));
 134   if(canvasView)
 135   {
 136     CanvasView& canvasViewImpl(GetImpl(canvasView));
 137
 138     switch(propertyIndex)
 139     {
 140       case Toolkit::CanvasView::Property::VIEW_BOX:
 141       {
 142         Vector2 valueVector2;
 143         if(value.Get(valueVector2))
 144         {
 145           canvasViewImpl.SetViewBox(valueVector2);
 146         }
 147         break;
 148       }
 149     }
 150   }
 151 }
 152
 153 Property::Value CanvasView::GetProperty(BaseObject* object, Property::Index propertyIndex)
 154 {
 155   Property::Value value;
 156
 157   Toolkit::CanvasView canvasView = Toolkit::CanvasView::DownCast(Dali::BaseHandle(object));
 158
 159   if(canvasView)
 160   {
 161     CanvasView& canvasViewImpl(GetImpl(canvasView));
 162
 163     switch(propertyIndex)
 164     {
 165       case Toolkit::CanvasView::Property::VIEW_BOX:
 166       {
 167         value = canvasViewImpl.GetViewBox();
 168         break;
 169       }
 170     }
 171   }
 172   return value;
 173 }
 174
 175 void CanvasView::Process(bool postProcessor)
 176 {
 177   if(mCanvasRenderer && mCanvasRenderer.IsCanvasChanged() && mSize.width > 0 && mSize.height > 0)
 178   {
 179     AddRasterizationTask();
 180   }
 181 }
 182
 183 void CanvasView::AddRasterizationTask()
 184 {
 185   CanvasRendererRasterizingTaskPtr newTask = new CanvasRendererRasterizingTask(this, mCanvasRenderer);
 186
 187   if(!mCanvasViewRasterizeThread)
 188   {
 189     mCanvasViewRasterizeThread = new CanvasViewRasterizeThread();
 190     mCanvasViewRasterizeThread->RasterizationCompletedSignal().Connect(this, &CanvasView::ApplyRasterizedImage);
 191     mCanvasViewRasterizeThread->Start();
 192   }
 193
 194   if(mCanvasRenderer.Commit())
 195   {
 196     mCanvasViewRasterizeThread->AddTask(newTask);
 197   }
 198 }
 199
 200 void CanvasView::ApplyRasterizedImage(Texture rasterizedTexture)
 201 {
 202   if (rasterizedTexture && rasterizedTexture.GetWidth() != 0 && rasterizedTexture.GetHeight() != 0)
 203   {
 204     if(!mTextureSet)
 205     {
 206       std::string fragmentShader = SHADER_CANVAS_VIEW_FRAG.data();
 207       DevelTexture::ApplyNativeFragmentShader(rasterizedTexture, fragmentShader);
 208
 209       mTextureSet       = TextureSet::New();
 210       Geometry geometry = VisualFactoryCache::CreateQuadGeometry();
 211       Shader   shader   = Shader::New(SHADER_CANVAS_VIEW_VERT, fragmentShader);
 212       Renderer renderer = Renderer::New(geometry, shader);
 213
 214       renderer.SetTextures(mTextureSet);
 215       renderer.SetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, true);
 216       Self().AddRenderer(renderer);
 217     }
 218     mTextureSet.SetTexture(0, rasterizedTexture);
 219   }
 220
 221   //If there are accumulated changes to CanvasRenderer during Rasterize, Rasterize once again.
 222   if(mCanvasRenderer && mCanvasRenderer.IsCanvasChanged())
 223   {
 224     AddRasterizationTask();
 225   }
 226 }
 227
 228 bool CanvasView::AddDrawable(Dali::CanvasRenderer::Drawable& drawable)
 229 {
 230   if(mCanvasRenderer && mCanvasRenderer.AddDrawable(drawable))
 231   {
 232     return true;
 233   }
 234   return false;
 235 }
 236
 237 bool CanvasView::RemoveDrawable(Dali::CanvasRenderer::Drawable& drawable)
 238 {
 239   if(mCanvasRenderer && mCanvasRenderer.RemoveDrawable(drawable))
 240   {
 241     return true;
 242   }
 243   return false;
 244 }
 245
 246 bool CanvasView::RemoveAllDrawables()
 247 {
 248   if(mCanvasRenderer && mCanvasRenderer.RemoveAllDrawables())
 249   {
 250     return true;
 251   }
 252   return false;
 253 }
 254
 255 bool CanvasView::SetViewBox(const Vector2& viewBox)
 256 {
 257   if(mCanvasRenderer && mCanvasRenderer.SetViewBox(viewBox))
 258   {
 259     return true;
 260   }
 261   return false;
 262 }
 263
 264 const Vector2& CanvasView::GetViewBox()
 265 {
 266   if(mCanvasRenderer)
 267   {
 268     return mCanvasRenderer.GetViewBox();
 269   }
 270   return Vector2::ZERO;
 271 }
 272 } // namespace Internal
 273 } // namespace Toolkit
 274 } // namespace Dali