dali-toolkit/internal/controls/super-blur-view/super-blur-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 "super-blur-view-impl.h"
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/devel-api/common/stage.h>
  23 #include <dali/devel-api/scripting/scripting.h>
  24 #include <dali/integration-api/debug.h>
  25 #include <dali/public-api/animation/constraint.h>
  26 #include <dali/public-api/object/property-map.h>
  27 #include <dali/public-api/object/type-registry-helper.h>
  28 #include <dali/public-api/object/type-registry.h>
  29 #include <dali/public-api/rendering/renderer.h>
  30 #include <cmath>
  31
  32 // INTERNAL_INCLUDES
  33 #include <dali-toolkit/devel-api/controls/control-devel.h>
  34 #include <dali-toolkit/internal/controls/control/control-data-impl.h>
  35 #include <dali-toolkit/internal/controls/control/control-renderers.h>
  36 #include <dali-toolkit/internal/graphics/builtin-shader-extern-gen.h>
  37 #include <dali-toolkit/internal/visuals/visual-base-impl.h>
  38 #include <dali-toolkit/internal/visuals/visual-factory-impl.h>
  39 #include <dali-toolkit/public-api/image-loader/sync-image-loader.h>
  40
  41 namespace //Unnamed namespace
  42 {
  43 using namespace Dali;
  44
  45 //Todo: make these properties instead of constants
  46 const unsigned int  GAUSSIAN_BLUR_DEFAULT_NUM_SAMPLES             = 11;
  47 const unsigned int  GAUSSIAN_BLUR_NUM_SAMPLES_INCREMENTATION      = 10;
  48 const float         GAUSSIAN_BLUR_BELL_CURVE_WIDTH                = 4.5f;
  49 const float         GAUSSIAN_BLUR_BELL_CURVE_WIDTH_INCREMENTATION = 5.f;
  50 const Pixel::Format GAUSSIAN_BLUR_RENDER_TARGET_PIXEL_FORMAT      = Pixel::RGBA8888;
  51 const float         GAUSSIAN_BLUR_DOWNSAMPLE_WIDTH_SCALE          = 0.5f;
  52 const float         GAUSSIAN_BLUR_DOWNSAMPLE_HEIGHT_SCALE         = 0.5f;
  53
  54 const char* ALPHA_UNIFORM_NAME("uAlpha");
  55
  56 /**
  57  * The constraint is used to blend the group of blurred images continuously with a unified blur strength property value which ranges from zero to one.
  58  */
  59 struct ActorOpacityConstraint
  60 {
  61   ActorOpacityConstraint(int totalImageNum, int currentImageIdx)
  62   {
  63     float rangeLength = 1.f / static_cast<float>(totalImageNum);
  64     float index       = static_cast<float>(currentImageIdx);
  65     mRange            = Vector2(index * rangeLength, (index + 1.f) * rangeLength);
  66   }
  67
  68   void operator()(float& current, const PropertyInputContainer& inputs)
  69   {
  70     float blurStrength = inputs[0]->GetFloat();
  71     if(blurStrength < mRange.x)
  72     {
  73       current = 0.f;
  74     }
  75     else if(blurStrength > mRange.y)
  76     {
  77       current = 1.f;
  78     }
  79     else
  80     {
  81       current = (blurStrength - mRange.x) / (mRange.y - mRange.x);
  82     }
  83   }
  84
  85   Vector2 mRange;
  86 };
  87
  88 } // namespace
  89
  90 namespace Dali
  91 {
  92 namespace Toolkit
  93 {
  94 namespace Internal
  95 {
  96 namespace
  97 {
  98 const unsigned int DEFAULT_BLUR_LEVEL(5u); ///< The default blur level when creating SuperBlurView from the type registry
  99
 100 BaseHandle Create()
 101 {
 102   return Toolkit::SuperBlurView::New(DEFAULT_BLUR_LEVEL);
 103 }
 104
 105 // Setup properties, signals and actions using the type-registry.
 106 DALI_TYPE_REGISTRATION_BEGIN(Toolkit::SuperBlurView, Toolkit::Control, Create)
 107
 108 DALI_PROPERTY_REGISTRATION(Toolkit, SuperBlurView, "imageUrl", STRING, IMAGE_URL)
 109
 110 DALI_TYPE_REGISTRATION_END()
 111
 112 } // unnamed namespace
 113
 114 SuperBlurView::SuperBlurView(unsigned int blurLevels)
 115 : Control(ControlBehaviour(DISABLE_SIZE_NEGOTIATION | DISABLE_STYLE_CHANGE_SIGNALS)),
 116   mTargetSize(Vector2::ZERO),
 117   mBlurStrengthPropertyIndex(Property::INVALID_INDEX),
 118   mBlurLevels(blurLevels),
 119   mResourcesCleared(true)
 120 {
 121   DALI_ASSERT_ALWAYS(mBlurLevels > 0 && " Minimal blur level is one, otherwise no blur is needed");
 122   mGaussianBlurView.assign(blurLevels, Toolkit::GaussianBlurView());
 123   mBlurredImage.assign(blurLevels, FrameBuffer());
 124   mRenderers.assign(blurLevels + 1, Dali::Renderer());
 125 }
 126
 127 SuperBlurView::~SuperBlurView()
 128 {
 129 }
 130
 131 Toolkit::SuperBlurView SuperBlurView::New(unsigned int blurLevels)
 132 {
 133   //Create the implementation
 134   IntrusivePtr<SuperBlurView> superBlurView(new SuperBlurView(blurLevels));
 135
 136   //Pass ownership to CustomActor via derived handle
 137   Toolkit::SuperBlurView handle(*superBlurView);
 138
 139   // Second-phase init of the implementation
 140   // This can only be done after the CustomActor connection has been made...
 141   superBlurView->Initialize();
 142
 143   return handle;
 144 }
 145
 146 void SuperBlurView::OnInitialize()
 147 {
 148   Actor self(Self());
 149
 150   mBlurStrengthPropertyIndex = self.RegisterUniqueProperty("blurStrength", 0.f);
 151
 152   DevelControl::SetAccessibilityConstructor(self, [](Dali::Actor actor) {
 153     return std::make_unique<DevelControl::ControlAccessible>(actor, Dali::Accessibility::Role::FILLER);
 154   });
 155 }
 156
 157 void SuperBlurView::SetTexture(Texture texture)
 158 {
 159   mInputTexture = texture;
 160
 161   if(mTargetSize == Vector2::ZERO)
 162   {
 163     return;
 164   }
 165
 166   ClearBlurResource();
 167
 168   Actor self(Self());
 169
 170   BlurTexture(0, mInputTexture);
 171   SetRendererTexture(mRenderers[0], texture);
 172
 173   unsigned int i = 1;
 174   for(; i < mBlurLevels; i++)
 175   {
 176     BlurTexture(i, mBlurredImage[i - 1].GetColorTexture());
 177     SetRendererTexture(mRenderers[i], mBlurredImage[i - 1]);
 178   }
 179
 180   SetRendererTexture(mRenderers[i], mBlurredImage[i - 1]);
 181
 182   mResourcesCleared = false;
 183 }
 184
 185 Property::Index SuperBlurView::GetBlurStrengthPropertyIndex() const
 186 {
 187   return mBlurStrengthPropertyIndex;
 188 }
 189
 190 void SuperBlurView::SetBlurStrength(float blurStrength)
 191 {
 192   Self().SetProperty(mBlurStrengthPropertyIndex, blurStrength);
 193 }
 194
 195 float SuperBlurView::GetCurrentBlurStrength() const
 196 {
 197   float blurStrength;
 198   (Self().GetProperty(mBlurStrengthPropertyIndex)).Get(blurStrength);
 199
 200   return blurStrength;
 201 }
 202
 203 Toolkit::SuperBlurView::SuperBlurViewSignal& SuperBlurView::BlurFinishedSignal()
 204 {
 205   return mBlurFinishedSignal;
 206 }
 207
 208 Texture SuperBlurView::GetBlurredTexture(unsigned int level)
 209 {
 210   DALI_ASSERT_ALWAYS(level > 0 && level <= mBlurLevels);
 211
 212   FrameBuffer frameBuffer = mBlurredImage[level - 1];
 213
 214   return frameBuffer.GetColorTexture();
 215 }
 216
 217 void SuperBlurView::BlurTexture(unsigned int idx, Texture texture)
 218 {
 219   DALI_ASSERT_ALWAYS(mGaussianBlurView.size() > idx);
 220   mGaussianBlurView[idx] = Toolkit::GaussianBlurView::New(GAUSSIAN_BLUR_DEFAULT_NUM_SAMPLES + GAUSSIAN_BLUR_NUM_SAMPLES_INCREMENTATION * idx,
 221                                                           GAUSSIAN_BLUR_BELL_CURVE_WIDTH + GAUSSIAN_BLUR_BELL_CURVE_WIDTH_INCREMENTATION * static_cast<float>(idx),
 222                                                           GAUSSIAN_BLUR_RENDER_TARGET_PIXEL_FORMAT,
 223                                                           GAUSSIAN_BLUR_DOWNSAMPLE_WIDTH_SCALE,
 224                                                           GAUSSIAN_BLUR_DOWNSAMPLE_HEIGHT_SCALE,
 225                                                           true);
 226   mGaussianBlurView[idx].SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
 227   mGaussianBlurView[idx].SetProperty(Actor::Property::SIZE, mTargetSize);
 228   Stage::GetCurrent().Add(mGaussianBlurView[idx]);
 229
 230   mGaussianBlurView[idx].SetUserImageAndOutputRenderTarget(texture, mBlurredImage[idx]);
 231
 232   mGaussianBlurView[idx].ActivateOnce();
 233   if(idx == mBlurLevels - 1)
 234   {
 235     mGaussianBlurView[idx].FinishedSignal().Connect(this, &SuperBlurView::OnBlurViewFinished);
 236   }
 237 }
 238
 239 void SuperBlurView::OnBlurViewFinished(Toolkit::GaussianBlurView blurView)
 240 {
 241   ClearBlurResource();
 242   Toolkit::SuperBlurView handle(GetOwner());
 243   mBlurFinishedSignal.Emit(handle);
 244 }
 245
 246 void SuperBlurView::ClearBlurResource()
 247 {
 248   if(!mResourcesCleared)
 249   {
 250     DALI_ASSERT_ALWAYS(mGaussianBlurView.size() == mBlurLevels && "must synchronize the GaussianBlurView group if blur levels got changed ");
 251     for(unsigned int i = 0; i < mBlurLevels; i++)
 252     {
 253       Stage::GetCurrent().Remove(mGaussianBlurView[i]);
 254       mGaussianBlurView[i].Deactivate();
 255     }
 256     mResourcesCleared = true;
 257   }
 258 }
 259
 260 void SuperBlurView::OnSizeSet(const Vector3& targetSize)
 261 {
 262   if(mTargetSize != Vector2(targetSize))
 263   {
 264     mTargetSize = Vector2(targetSize);
 265
 266     Actor self = Self();
 267     for(unsigned int i = 1; i <= mBlurLevels; i++)
 268     {
 269       float exponent = static_cast<float>(i);
 270
 271       unsigned int width  = mTargetSize.width / std::pow(2.f, exponent);
 272       unsigned int height = mTargetSize.height / std::pow(2.f, exponent);
 273
 274       mBlurredImage[i - 1] = FrameBuffer::New(width, height, FrameBuffer::Attachment::NONE);
 275       Texture texture      = Texture::New(TextureType::TEXTURE_2D, GAUSSIAN_BLUR_RENDER_TARGET_PIXEL_FORMAT, unsigned(width), unsigned(height));
 276       mBlurredImage[i - 1].AttachColorTexture(texture);
 277     }
 278
 279     if(mInputTexture)
 280     {
 281       SetTexture(mInputTexture);
 282     }
 283   }
 284
 285   Control::OnSizeSet(targetSize);
 286 }
 287
 288 void SuperBlurView::OnSceneConnection(int depth)
 289 {
 290   if(mTargetSize == Vector2::ZERO)
 291   {
 292     return;
 293   }
 294
 295   // Exception to the rule, chaining up first ensures visuals have SetOnScene called to create their renderers
 296   Control::OnSceneConnection(depth);
 297
 298   Actor self = Self();
 299
 300   for(unsigned int i = 0; i < mBlurLevels + 1; i++)
 301   {
 302     mRenderers[i] = CreateRenderer(BASIC_VERTEX_SOURCE, SHADER_SUPER_BLUR_VIEW_FRAG);
 303     mRenderers[i].SetProperty(Dali::Renderer::Property::DEPTH_INDEX, (int)i);
 304     self.AddRenderer(mRenderers[i]);
 305
 306     if(i > 0)
 307     {
 308       Renderer        renderer   = mRenderers[i];
 309       Property::Index index      = renderer.RegisterUniqueProperty(ALPHA_UNIFORM_NAME, 0.f);
 310       Constraint      constraint = Constraint::New<float>(renderer, index, ActorOpacityConstraint(mBlurLevels, i - 1));
 311       constraint.AddSource(Source(self, mBlurStrengthPropertyIndex));
 312       constraint.Apply();
 313     }
 314   }
 315
 316   if(mInputTexture)
 317   {
 318     SetRendererTexture(mRenderers[0], mInputTexture);
 319     unsigned int i = 1;
 320     for(; i < mBlurLevels; i++)
 321     {
 322       SetRendererTexture(mRenderers[i], mBlurredImage[i - 1]);
 323     }
 324     SetRendererTexture(mRenderers[i], mBlurredImage[i - 1]);
 325   }
 326 }
 327
 328 void SuperBlurView::OnSceneDisconnection()
 329 {
 330   for(unsigned int i = 0; i < mBlurLevels + 1; i++)
 331   {
 332     Self().RemoveRenderer(mRenderers[i]);
 333     mRenderers[i].Reset();
 334   }
 335
 336   Control::OnSceneDisconnection();
 337 }
 338
 339 Vector3 SuperBlurView::GetNaturalSize()
 340 {
 341   if(mInputTexture)
 342   {
 343     return Vector3(mInputTexture.GetWidth(), mInputTexture.GetHeight(), 0.f);
 344   }
 345   return Vector3::ZERO;
 346 }
 347
 348 void SuperBlurView::SetProperty(BaseObject* object, Property::Index propertyIndex, const Property::Value& value)
 349 {
 350   Toolkit::SuperBlurView superBlurView = Toolkit::SuperBlurView::DownCast(Dali::BaseHandle(object));
 351
 352   if(superBlurView)
 353   {
 354     SuperBlurView& superBlurViewImpl(GetImpl(superBlurView));
 355
 356     if(propertyIndex == Toolkit::SuperBlurView::Property::IMAGE_URL)
 357     {
 358       value.Get(superBlurViewImpl.mUrl);
 359
 360       PixelData pixels = SyncImageLoader::Load(superBlurViewImpl.mUrl);
 361
 362       if(pixels)
 363       {
 364         Texture texture = Texture::New(TextureType::TEXTURE_2D, pixels.GetPixelFormat(), pixels.GetWidth(), pixels.GetHeight());
 365         texture.Upload(pixels, 0, 0, 0, 0, pixels.GetWidth(), pixels.GetHeight());
 366
 367         superBlurViewImpl.SetTexture(texture);
 368       }
 369       else
 370       {
 371         DALI_LOG_ERROR("Cannot create image from property value\n");
 372       }
 373     }
 374   }
 375 }
 376
 377 Property::Value SuperBlurView::GetProperty(BaseObject* object, Property::Index propertyIndex)
 378 {
 379   Property::Value value;
 380
 381   Toolkit::SuperBlurView blurView = Toolkit::SuperBlurView::DownCast(Dali::BaseHandle(object));
 382
 383   if(blurView)
 384   {
 385     SuperBlurView& superBlurViewImpl(GetImpl(blurView));
 386
 387     if(propertyIndex == Toolkit::SuperBlurView::Property::IMAGE_URL)
 388     {
 389       value = superBlurViewImpl.mUrl;
 390     }
 391   }
 392
 393   return value;
 394 }
 395
 396 } // namespace Internal
 397
 398 } // namespace Toolkit
 399
 400 } // namespace Dali