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