dali-toolkit/internal/controls/super-blur-view/super-blur-view-impl.cpp

   1 /*
   2  * Copyright (c) 2014 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 <cmath>
  23 #include <dali/public-api/animation/constraint.h>
  24 #include <dali/public-api/common/stage.h>
  25 #include <dali/public-api/object/type-registry.h>
  26 #include <dali/public-api/object/type-registry-helper.h>
  27 #include <dali/public-api/scripting/scripting.h>
  28 #include <dali/integration-api/debug.h>
  29
  30 namespace //Unnamed namespace
  31 {
  32
  33 using namespace Dali;
  34
  35 //Todo: make these properties instead of constants
  36 const unsigned int GAUSSIAN_BLUR_DEFAULT_NUM_SAMPLES = 11;
  37 const unsigned int GAUSSIAN_BLUR_NUM_SAMPLES_INCREMENTATION = 10;
  38 const float GAUSSIAN_BLUR_BELL_CURVE_WIDTH = 4.5f;
  39 const float GAUSSIAN_BLUR_BELL_CURVE_WIDTH_INCREMENTATION = 5.f;
  40 const Pixel::Format GAUSSIAN_BLUR_RENDER_TARGET_PIXEL_FORMAT = Pixel::RGB888;
  41 const float GAUSSIAN_BLUR_DOWNSAMPLE_WIDTH_SCALE = 0.5f;
  42 const float GAUSSIAN_BLUR_DOWNSAMPLE_HEIGHT_SCALE = 0.5f;
  43
  44 /**
  45  * 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.
  46  */
  47 struct ActorOpacityConstraint
  48 {
  49   ActorOpacityConstraint(int totalImageNum, int currentImageIdx)
  50   {
  51     float rangeLength = 1.f / static_cast<float>( totalImageNum );
  52     float index = static_cast<float>( currentImageIdx );
  53     mRange = Vector2( index*rangeLength, (index+1.f)*rangeLength );
  54   }
  55
  56   void operator()( float& current, const PropertyInputContainer& inputs )
  57   {
  58     float blurStrength = inputs[0]->GetFloat();
  59     if(blurStrength <= mRange.x)
  60     {
  61       current = 1.f;
  62     }
  63     else if(blurStrength > mRange.y)
  64     {
  65       current = 0.f;
  66     }
  67     else
  68     {
  69       current = ( mRange.y - blurStrength) / ( mRange.y - mRange.x );
  70     }
  71   }
  72
  73   Vector2 mRange;
  74 };
  75
  76 } // namespace
  77
  78 namespace Dali
  79 {
  80
  81 namespace Toolkit
  82 {
  83
  84 namespace Internal
  85 {
  86
  87 namespace
  88 {
  89
  90 const unsigned int DEFAULT_BLUR_LEVEL(5u); ///< The default blur level when creating SuperBlurView from the type registry
  91
  92 BaseHandle Create()
  93 {
  94   return Toolkit::SuperBlurView::New( DEFAULT_BLUR_LEVEL );
  95 }
  96
  97 // Setup properties, signals and actions using the type-registry.
  98 DALI_TYPE_REGISTRATION_BEGIN( Toolkit::SuperBlurView, Toolkit::Control, Create )
  99
 100 DALI_PROPERTY_REGISTRATION( SuperBlurView, "image", MAP, IMAGE )
 101
 102 DALI_TYPE_REGISTRATION_END()
 103
 104 } // unnamed namespace
 105
 106 SuperBlurView::SuperBlurView( unsigned int blurLevels )
 107 : Control( CONTROL_BEHAVIOUR_NONE ),
 108   mBlurLevels( blurLevels ),
 109   mBlurStrengthPropertyIndex(Property::INVALID_INDEX),
 110   mResourcesCleared( true ),
 111   mTargetSize( Vector2::ZERO )
 112 {
 113   DALI_ASSERT_ALWAYS( mBlurLevels > 0 && " Minimal blur level is one, otherwise no blur is needed" );
 114   mGaussianBlurView.assign( blurLevels, NULL );
 115   mBlurredImage.assign( blurLevels, FrameBufferImage() );
 116   mImageActors.assign( blurLevels + 1, ImageActor() );
 117 }
 118
 119 SuperBlurView::~SuperBlurView()
 120 {
 121 }
 122
 123 Toolkit::SuperBlurView SuperBlurView::New( unsigned int blurLevels )
 124 {
 125   //Create the implementation
 126   IntrusivePtr<SuperBlurView> superBlurView( new SuperBlurView( blurLevels ) );
 127
 128   //Pass ownership to CustomActor via derived handle
 129   Toolkit::SuperBlurView handle( *superBlurView );
 130
 131   // Second-phase init of the implementation
 132   // This can only be done after the CustomActor connection has been made...
 133   superBlurView->Initialize();
 134
 135   return handle;
 136 }
 137
 138 void SuperBlurView::OnInitialize()
 139 {
 140   mBlurStrengthPropertyIndex = Self().RegisterProperty( "blur-strength",0.f );
 141
 142   DALI_ASSERT_ALWAYS( mImageActors.size() == mBlurLevels+1 && "must synchronize the ImageActor group if blur levels got changed " );
 143   for(unsigned int i=0; i<=mBlurLevels;i++)
 144   {
 145     mImageActors[i] = ImageActor::New(  );
 146     mImageActors[i].SetResizePolicy( FILL_TO_PARENT, ALL_DIMENSIONS );
 147     mImageActors[i].SetParentOrigin( ParentOrigin::CENTER );
 148     mImageActors[i].SetZ(-static_cast<float>(i)*0.01f);
 149     mImageActors[i].SetColorMode( USE_OWN_MULTIPLY_PARENT_ALPHA );
 150     Self().Add( mImageActors[i] );
 151   }
 152
 153   for(unsigned int i=0; i < mBlurLevels; i++)
 154   {
 155     Constraint constraint = Constraint::New<float>( mImageActors[i], Actor::Property::COLOR_ALPHA, ActorOpacityConstraint(mBlurLevels, i) );
 156     constraint.AddSource( ParentSource( mBlurStrengthPropertyIndex ) );
 157     constraint.Apply();
 158   }
 159
 160   Self().SetSize(Stage::GetCurrent().GetSize());
 161 }
 162
 163 void SuperBlurView::SetImage(Image inputImage)
 164 {
 165   DALI_ASSERT_ALWAYS( mImageActors.size() == mBlurLevels+1 && "must synchronize the ImageActor group if blur levels got changed " );
 166   DALI_ASSERT_ALWAYS( mBlurredImage.size() == mBlurLevels && "must synchronize the blurred image group if blur levels got changed " );
 167
 168   ClearBlurResource();
 169
 170   mImageActors[0].SetImage( inputImage );
 171
 172   for(unsigned int i=1; i<=mBlurLevels;i++)
 173   {
 174     mImageActors[i].SetImage( mBlurredImage[i-1] );
 175   }
 176
 177   BlurImage( 0,  inputImage);
 178   for(unsigned int i=1; i<mBlurLevels;i++)
 179   {
 180     BlurImage( i,  mBlurredImage[i-1]);
 181   }
 182
 183   mResourcesCleared = false;
 184 }
 185
 186 Property::Index SuperBlurView::GetBlurStrengthPropertyIndex() const
 187 {
 188   return mBlurStrengthPropertyIndex;
 189 }
 190
 191 void SuperBlurView::SetBlurStrength( float blurStrength )
 192 {
 193   Self().SetProperty(mBlurStrengthPropertyIndex, blurStrength);
 194 }
 195
 196 float SuperBlurView::GetCurrentBlurStrength() const
 197 {
 198   float blurStrength;
 199   (Self().GetProperty( mBlurStrengthPropertyIndex )).Get(blurStrength);
 200
 201   return blurStrength;
 202 }
 203
 204 Toolkit::SuperBlurView::SuperBlurViewSignal& SuperBlurView::BlurFinishedSignal()
 205 {
 206   return mBlurFinishedSignal;
 207 }
 208
 209 Image SuperBlurView::GetBlurredImage( unsigned int level )
 210 {
 211   DALI_ASSERT_ALWAYS( level>0 && level<=mBlurLevels );
 212   return mBlurredImage[level-1];
 213 }
 214
 215 void SuperBlurView::BlurImage( unsigned int idx, Image image )
 216 {
 217   DALI_ASSERT_ALWAYS( mGaussianBlurView.size()>idx );
 218   mGaussianBlurView[idx] = Toolkit::GaussianBlurView::New( GAUSSIAN_BLUR_DEFAULT_NUM_SAMPLES+GAUSSIAN_BLUR_NUM_SAMPLES_INCREMENTATION*idx,
 219                                                            GAUSSIAN_BLUR_BELL_CURVE_WIDTH + GAUSSIAN_BLUR_BELL_CURVE_WIDTH_INCREMENTATION*static_cast<float>(idx),
 220                                                            GAUSSIAN_BLUR_RENDER_TARGET_PIXEL_FORMAT,
 221                                                            GAUSSIAN_BLUR_DOWNSAMPLE_WIDTH_SCALE, GAUSSIAN_BLUR_DOWNSAMPLE_HEIGHT_SCALE, true );
 222   mGaussianBlurView[idx].SetParentOrigin(ParentOrigin::CENTER);
 223   mGaussianBlurView[idx].SetSize(mTargetSize);
 224   mGaussianBlurView[idx].SetUserImageAndOutputRenderTarget( image, mBlurredImage[idx] );
 225   if( idx == mBlurLevels-1 )
 226   {
 227     mGaussianBlurView[idx].FinishedSignal().Connect( this, &SuperBlurView::OnBlurViewFinished );
 228   }
 229   Stage::GetCurrent().Add( mGaussianBlurView[idx] );
 230   mGaussianBlurView[idx].ActivateOnce();
 231 }
 232
 233 void SuperBlurView::OnBlurViewFinished( Toolkit::GaussianBlurView blurView )
 234 {
 235   ClearBlurResource();
 236   Toolkit::SuperBlurView handle( GetOwner() );
 237   mBlurFinishedSignal.Emit( handle );
 238 }
 239
 240 void SuperBlurView::ClearBlurResource()
 241 {
 242   if( !mResourcesCleared )
 243   {
 244     DALI_ASSERT_ALWAYS( mGaussianBlurView.size() == mBlurLevels && "must synchronize the GaussianBlurView group if blur levels got changed " );
 245     for(unsigned int i=0; i<mBlurLevels;i++)
 246     {
 247       Stage::GetCurrent().Remove( mGaussianBlurView[i] );
 248       mGaussianBlurView[i].Deactivate();
 249       mGaussianBlurView[i].Reset();
 250     }
 251     mResourcesCleared = true;
 252   }
 253 }
 254
 255 void SuperBlurView::OnControlSizeSet( const Vector3& targetSize )
 256 {
 257   if( mTargetSize != Vector2(targetSize) )
 258   {
 259     mTargetSize = Vector2(targetSize);
 260
 261     for(unsigned int i=0; i<mBlurLevels;i++)
 262     {
 263       float exponent = static_cast<float>(i+1);
 264       mBlurredImage[i] = FrameBufferImage::New( mTargetSize.width/std::pow(2.f,exponent) , mTargetSize.height/std::pow(2.f,exponent),
 265                                                 GAUSSIAN_BLUR_RENDER_TARGET_PIXEL_FORMAT, Dali::Image::NEVER );
 266     }
 267   }
 268 }
 269
 270 void SuperBlurView::SetProperty( BaseObject* object, Property::Index propertyIndex, const Property::Value& value )
 271 {
 272   Toolkit::SuperBlurView superBlurView = Toolkit::SuperBlurView::DownCast( Dali::BaseHandle( object ) );
 273
 274   if( superBlurView )
 275   {
 276     SuperBlurView& superBlurViewImpl( GetImpl( superBlurView ) );
 277
 278     if( propertyIndex == Toolkit::SuperBlurView::Property::IMAGE )
 279     {
 280       Dali::Image image = Scripting::NewImage( value );
 281       if ( image )
 282       {
 283         superBlurViewImpl.SetImage( image );
 284       }
 285       else
 286       {
 287         DALI_LOG_ERROR( "Cannot create image from property value\n" );
 288       }
 289     }
 290   }
 291 }
 292
 293 Property::Value SuperBlurView::GetProperty( BaseObject* object, Property::Index propertyIndex )
 294 {
 295   Property::Value value;
 296
 297   Toolkit::SuperBlurView pushButton = Toolkit::SuperBlurView::DownCast( Dali::BaseHandle( object ) );
 298
 299   if( pushButton )
 300   {
 301     SuperBlurView& superBlurViewImpl( GetImpl( pushButton ) );
 302
 303     if( propertyIndex == Toolkit::SuperBlurView::Property::IMAGE )
 304     {
 305       Property::Map map;
 306       if( !superBlurViewImpl.mImageActors.empty() && superBlurViewImpl.mImageActors[0] )
 307       {
 308         Scripting::CreatePropertyMap( superBlurViewImpl.mImageActors[0], map );
 309       }
 310       value = Property::Value( map );
 311     }
 312   }
 313
 314   return value;
 315 }
 316
 317 } // namespace Internal
 318
 319 } // namespace Toolkit
 320
 321 } // namespace Dali