dali-toolkit/internal/controls/effects-view/effects-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 "effects-view-impl.h"
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/public-api/animation/constraint.h>
  23 #include <dali/public-api/animation/constraints.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/render-tasks/render-task-list.h>
  28
  29 // INTERNAL INCLUDES
  30 #include "../../filters/blur-two-pass-filter.h"
  31 #include "../../filters/emboss-filter.h"
  32 #include "../../filters/spread-filter.h"
  33
  34 namespace Dali
  35 {
  36
  37 namespace Toolkit
  38 {
  39
  40 namespace Internal
  41 {
  42
  43 namespace
  44 {
  45
  46 Dali::BaseHandle Create()
  47 {
  48   return Toolkit::EffectsView::New();
  49 }
  50
  51 DALI_TYPE_REGISTRATION_BEGIN( Toolkit::EffectsView, Toolkit::Control, Create )
  52 DALI_TYPE_REGISTRATION_END()
  53
  54 const Pixel::Format EFFECTS_VIEW_DEFAULT_PIXEL_FORMAT = Pixel::RGBA8888;
  55 const float         ARBITRARY_FIELD_OF_VIEW = Math::PI / 4.0f;
  56 const Vector4       EFFECTS_VIEW_DEFAULT_BACKGROUND_COLOR( 1.0f, 1.0f, 1.0f, 0.0 );
  57 const bool          EFFECTS_VIEW_REFRESH_ON_DEMAND(false);
  58
  59 // Custom properties
  60 const char* const   EFFECT_SIZE_PROPERTY_NAME = "EffectSize";
  61 const char* const   EFFECT_STRENGTH_PROPERTY_NAME = "EffectStrength";
  62 const char* const   EFFECT_OFFSET_PROPERTY_NAME = "EffectOffset";
  63 const char* const   EFFECT_COLOR_PROPERTY_NAME = "EffectColor";
  64
  65 const float         EFFECT_SIZE_DEFAULT( 1.0f );
  66 const float         EFFECT_STRENGTH_DEFAULT( 0.5f );
  67 const Vector3       EFFECT_OFFSET_DEFAULT( 0.0f, 0.0f, 0.0f );
  68 const Vector4       EFFECT_COLOR_DEFAULT( Color::WHITE );
  69
  70 const char* const EFFECTS_VIEW_FRAGMENT_SOURCE =
  71     "void main()\n"
  72     "{\n"
  73     "  gl_FragColor = uColor;\n"
  74     "  gl_FragColor.a *= texture2D( sTexture, vTexCoord).a;\n"
  75     "}\n";
  76
  77 const float BLUR_KERNEL0[] = { 12.0f/16.0f,
  78                                2.0f/16.0f, 2.0f/16.0f };
  79
  80 const float BLUR_KERNEL1[] = { 8.0f/16.0f,
  81                                4.0f/16.0f, 4.0f/16.0f };
  82
  83 const float BLUR_KERNEL2[] = { 6.0f/16.0f,
  84                                2.5f/16.0f, 2.5f/16.0f,
  85                                1.5f/16.0f, 1.5f/16.0f,
  86                                1.0f/16.0f, 1.0f/16.0f };
  87
  88 const float BLUR_KERNEL3[] = { 4.0f/16.0f,
  89                                3.0f/16.0f, 2.0f/16.0f,
  90                                2.0f/16.0f, 2.0f/16.0f,
  91                                1.0f/16.0f, 1.0f/16.0f };
  92
  93 const float BLUR_KERNEL4[] = { 3.0f/16.0f,
  94                                2.5f/16.0f,  2.5f/16.0f,
  95                                1.75f/16.0f, 1.75f/16.0f,
  96                                1.25f/16.0f, 1.25f/16.0f,
  97                                1.0f/16.0f,  1.0f/16.0f };
  98
  99 } // namespace
 100
 101 Toolkit::EffectsView EffectsView::New()
 102 {
 103   EffectsView* effectsView = new EffectsView;
 104
 105   Toolkit::EffectsView handle = Toolkit::EffectsView( *effectsView );
 106
 107   // Second-phase init of the implementation
 108   // This can only be done after the CustomActor connection has been made...
 109   effectsView->Initialize();
 110
 111   return handle;
 112 }
 113
 114 EffectsView::EffectsView()
 115 : Control( CONTROL_BEHAVIOUR_NONE ),
 116   mEffectType( Toolkit::EffectsView::INVALID_TYPE ),
 117   mPixelFormat( EFFECTS_VIEW_DEFAULT_PIXEL_FORMAT ),
 118   mSpread(0.0f),
 119   mBackgroundColor( EFFECTS_VIEW_DEFAULT_BACKGROUND_COLOR ),
 120   mTargetSize( Vector2::ZERO ),
 121   mLastSize( Vector2::ZERO ),
 122   mRefreshOnDemand(EFFECTS_VIEW_REFRESH_ON_DEMAND),
 123   mEffectSizePropertyIndex(Property::INVALID_INDEX),
 124   mEffectStrengthPropertyIndex(Property::INVALID_INDEX),
 125   mEffectOffsetPropertyIndex(Property::INVALID_INDEX),
 126   mEffectColorPropertyIndex(Property::INVALID_INDEX)
 127 {
 128 }
 129
 130 EffectsView::~EffectsView()
 131 {
 132   RemoveFilters();
 133 }
 134
 135 void EffectsView::SetType( Toolkit::EffectsView::EffectType type )
 136 {
 137   if( mEffectType != type )
 138   {
 139     mEffectType = type;
 140
 141     RemoveFilters();
 142
 143     switch( mEffectType )
 144     {
 145       case Toolkit::EffectsView::DROP_SHADOW:
 146       {
 147         mFilters.push_back( new SpreadFilter );
 148         mFilters.push_back( new BlurTwoPassFilter );
 149         break;
 150       }
 151       case Toolkit::EffectsView::EMBOSS:
 152       {
 153         mFilters.push_back( new SpreadFilter );
 154         mFilters.push_back( new EmbossFilter );
 155         mFilters.push_back( new BlurTwoPassFilter );
 156         mActorPostFilter.RemoveShaderEffect();
 157         break;
 158       }
 159       default:
 160       {
 161         break;
 162       }
 163     }
 164   }
 165 }
 166
 167 Toolkit::EffectsView::EffectType EffectsView::GetType() const
 168 {
 169   return mEffectType;
 170 }
 171
 172 void EffectsView::Enable()
 173 {
 174   // make sure resources are allocated and start the render tasks processing
 175   AllocateResources();
 176   CreateRenderTasks();
 177 }
 178
 179 void EffectsView::Disable()
 180 {
 181   // stop render tasks processing
 182   // Note: render target resources are automatically freed since we set the Image::Unused flag
 183   RemoveRenderTasks();
 184 }
 185
 186 void EffectsView::Refresh()
 187 {
 188   RefreshRenderTasks();
 189 }
 190
 191 void EffectsView::SetRefreshOnDemand( bool onDemand )
 192 {
 193   mRefreshOnDemand = onDemand;
 194
 195   RefreshRenderTasks();
 196 }
 197
 198 void EffectsView::SetPixelFormat( Pixel::Format pixelFormat )
 199 {
 200   mPixelFormat = pixelFormat;
 201 }
 202
 203 void EffectsView::SetOutputImage( FrameBufferImage image )
 204 {
 205   CustomActor self = Self();
 206
 207   if( mImageForResult != image )
 208   {
 209     if( !image )
 210     {
 211       if( mImageForResult )
 212       {
 213         self.Remove( mActorForResult );
 214         mActorForResult.Reset();
 215
 216         self.Add( mActorPostFilter );
 217         self.Add( mActorForChildren );
 218       }
 219     }
 220     else
 221     {
 222       if( mImageForResult )
 223       {
 224         self.Remove( mActorForResult );
 225       }
 226       mActorForResult = Actor::New();
 227       mActorForResult.SetParentOrigin( ParentOrigin::CENTER );
 228       mActorForResult.SetSize( mTargetSize );
 229       mActorForResult.ScaleBy( Vector3(1.0f, -1.0f, 1.0f) );
 230
 231       Self().Add( mActorForResult );
 232       mActorForResult.Add( mActorPostFilter );
 233       mActorForResult.Add( mActorForChildren );
 234     }
 235     mImageForResult = image;
 236   }
 237 }
 238
 239 FrameBufferImage EffectsView::GetOutputImage()
 240 {
 241   return mImageForResult;
 242 }
 243
 244 Property::Index EffectsView::GetEffectSizePropertyIndex() const
 245 {
 246   return mEffectSizePropertyIndex;
 247 }
 248
 249 Property::Index EffectsView::GetEffectStrengthPropertyIndex() const
 250 {
 251   return mEffectStrengthPropertyIndex;
 252 }
 253
 254 Property::Index EffectsView::GetEffectOffsetPropertyIndex() const
 255 {
 256   return mEffectOffsetPropertyIndex;
 257 }
 258
 259 Property::Index EffectsView::GetEffectColorPropertyIndex() const
 260 {
 261   return mEffectColorPropertyIndex;
 262 }
 263
 264 void EffectsView::SetupProperties()
 265 {
 266   CustomActor self = Self();
 267
 268   // Register a property that the user can control the drop shadow offset
 269   mEffectSizePropertyIndex     = self.RegisterProperty(EFFECT_SIZE_PROPERTY_NAME, EFFECT_SIZE_DEFAULT, Property::READ_WRITE);
 270   mEffectStrengthPropertyIndex = self.RegisterProperty(EFFECT_STRENGTH_PROPERTY_NAME, EFFECT_STRENGTH_DEFAULT, Property::READ_WRITE);
 271   mEffectOffsetPropertyIndex   = self.RegisterProperty(EFFECT_OFFSET_PROPERTY_NAME, EFFECT_OFFSET_DEFAULT);
 272   mEffectColorPropertyIndex    = self.RegisterProperty(EFFECT_COLOR_PROPERTY_NAME, EFFECT_COLOR_DEFAULT);
 273
 274   Constraint positionConstraint = Constraint::New<Vector3>( mActorPostFilter, Actor::Property::POSITION, EqualToConstraint() );
 275   positionConstraint.AddSource( Source( self, mEffectOffsetPropertyIndex ) );
 276   positionConstraint.Apply();
 277
 278   Constraint colorConstraint = Constraint::New<Vector4>( mActorPostFilter, Actor::Property::COLOR, EqualToConstraint() );
 279   colorConstraint.AddSource( Source( self, mEffectColorPropertyIndex ) );
 280   colorConstraint.Apply();
 281 }
 282
 283 void EffectsView::SetBackgroundColor( const Vector4& color )
 284 {
 285   mBackgroundColor = color;
 286 }
 287
 288 Vector4 EffectsView::GetBackgroundColor() const
 289 {
 290   return mBackgroundColor;
 291 }
 292
 293 // From Control
 294 void EffectsView::OnInitialize()
 295 {
 296   //////////////////////////////////////////////////////
 297   // Create cameras
 298   mCameraForChildren = CameraActor::New();
 299   mCameraForChildren.SetParentOrigin(ParentOrigin::CENTER);
 300
 301   mActorForChildren = ImageActor::New();
 302   mActorForChildren.SetPositionInheritanceMode( Dali::USE_PARENT_POSITION );
 303   mActorForChildren.ScaleBy( Vector3(1.0f, -1.0f, 1.0f) );
 304
 305   mActorPostFilter = ImageActor::New();
 306   mActorPostFilter.SetParentOrigin( ParentOrigin::CENTER );
 307   mActorPostFilter.ScaleBy( Vector3(1.0f, -1.0f, 1.0f) );
 308   mActorPostFilter.SetShaderEffect( ShaderEffect::New( "", EFFECTS_VIEW_FRAGMENT_SOURCE ) );
 309
 310   // Connect to actor tree
 311   Self().Add( mActorPostFilter );
 312   Self().Add( mActorForChildren );
 313   Self().Add( mCameraForChildren );
 314
 315   SetupProperties();
 316 }
 317
 318 void EffectsView::OnControlSizeSet(const Vector3& targetSize)
 319 {
 320   mTargetSize = Vector2(targetSize);
 321
 322   // if we are already on stage, need to update render target sizes now to reflect the new size of this actor
 323   if(Self().OnStage())
 324   {
 325     AllocateResources();
 326   }
 327
 328   if( mActorForResult )
 329   {
 330     mActorForResult.SetSize( targetSize );
 331   }
 332   if( mActorForChildren )
 333   {
 334     mActorForChildren.SetSize( targetSize );
 335   }
 336   if( mActorPostFilter )
 337   {
 338     mActorPostFilter.SetSize( targetSize );
 339   }
 340
 341   // Children render camera must move when EffectsView object is resized.
 342   // This is since we cannot change render target size - so we need to remap the child actors' rendering
 343   // accordingly so they still exactly fill the render target.
 344   // Note that this means the effective resolution of the child render changes as the EffectsView object
 345   // changes size, this is the trade off for not being able to modify render target size
 346   // Change camera z position based on EffectsView actor height
 347   if( mCameraForChildren )
 348   {
 349     const float cameraPosScale( 0.5f / tanf(ARBITRARY_FIELD_OF_VIEW * 0.5f) );
 350     mCameraForChildren.SetZ( targetSize.height * cameraPosScale );
 351   }
 352
 353   const size_t numFilters( mFilters.size() );
 354   for( size_t i = 0; i < numFilters; ++i )
 355   {
 356     mFilters[i]->SetSize( mTargetSize );
 357   }
 358
 359 }
 360
 361 void EffectsView::OnStageDisconnection()
 362 {
 363   const size_t numFilters( mFilters.size() );
 364   for( size_t i = 0; i < numFilters; ++i )
 365   {
 366     mFilters[i]->Disable();
 367   }
 368 }
 369
 370 void EffectsView::SetupFilters()
 371 {
 372   int effectSize = static_cast< int >( Self().GetProperty( mEffectSizePropertyIndex ).Get<float>() );
 373   switch( mEffectType )
 374   {
 375     case Toolkit::EffectsView::DROP_SHADOW:
 376     {
 377       SpreadFilter* spreadFilter = static_cast< SpreadFilter* >( mFilters[0] );
 378       spreadFilter->SetInputImage( mImageForChildren );
 379       spreadFilter->SetOutputImage( mImagePostFilter );
 380       spreadFilter->SetRootActor( Self() );
 381       spreadFilter->SetBackgroundColor( mBackgroundColor );
 382       spreadFilter->SetPixelFormat( mPixelFormat );
 383       spreadFilter->SetSize( mTargetSize );
 384       spreadFilter->SetSpread( effectSize );
 385
 386       BlurTwoPassFilter* blurFilter = static_cast< BlurTwoPassFilter* >( mFilters[1] );
 387       blurFilter->SetInputImage( mImagePostFilter );
 388       blurFilter->SetOutputImage( mImagePostFilter );
 389       blurFilter->SetRootActor( Self() );
 390       blurFilter->SetBackgroundColor( mBackgroundColor );
 391       blurFilter->SetPixelFormat( mPixelFormat );
 392       blurFilter->SetSize( mTargetSize );
 393
 394       const float* kernel(NULL);
 395       size_t kernelSize(0);
 396       switch( effectSize )
 397       {
 398         case 4:  {  kernel = BLUR_KERNEL4; kernelSize = sizeof(BLUR_KERNEL4)/sizeof(BLUR_KERNEL4[0]); break; }
 399         case 3:  {  kernel = BLUR_KERNEL3; kernelSize = sizeof(BLUR_KERNEL3)/sizeof(BLUR_KERNEL3[0]); break; }
 400         case 2:  {  kernel = BLUR_KERNEL2; kernelSize = sizeof(BLUR_KERNEL2)/sizeof(BLUR_KERNEL2[0]); break; }
 401         case 1:  {  kernel = BLUR_KERNEL1; kernelSize = sizeof(BLUR_KERNEL1)/sizeof(BLUR_KERNEL1[0]); break; }
 402         case 0:
 403         default: {  kernel = BLUR_KERNEL0; kernelSize = sizeof(BLUR_KERNEL0)/sizeof(BLUR_KERNEL0[0]); break; }
 404       }
 405       blurFilter->CreateKernel( kernel, kernelSize );
 406       break;
 407     }
 408     case Toolkit::EffectsView::EMBOSS:
 409     {
 410       SpreadFilter* spreadFilter = static_cast< SpreadFilter* >( mFilters[0] );
 411       spreadFilter->SetInputImage( mImageForChildren );
 412       spreadFilter->SetOutputImage( mImagePostFilter );
 413       spreadFilter->SetRootActor( Self() );
 414       spreadFilter->SetBackgroundColor( mBackgroundColor );
 415       spreadFilter->SetPixelFormat( Pixel::RGBA8888 );
 416       spreadFilter->SetSize( mTargetSize );
 417       spreadFilter->SetSpread( effectSize );
 418
 419       EmbossFilter* embossFilter = static_cast< EmbossFilter* >( mFilters[1] );
 420       embossFilter->SetInputImage( mImagePostFilter );
 421       embossFilter->SetOutputImage( mImagePostFilter );
 422       embossFilter->SetRootActor( Self() );
 423       embossFilter->SetBackgroundColor( mBackgroundColor );
 424       embossFilter->SetPixelFormat( Pixel::RGBA8888 );
 425       embossFilter->SetSize( mTargetSize );
 426
 427       BlurTwoPassFilter* blurFilter = static_cast< BlurTwoPassFilter* >( mFilters[2] );
 428       blurFilter->SetInputImage( mImagePostFilter );
 429       blurFilter->SetOutputImage( mImagePostFilter );
 430       blurFilter->SetRootActor( Self() );
 431       blurFilter->SetBackgroundColor( Vector4( 0.5f, 0.5f, 0.5f, 0.0 ) );
 432       blurFilter->SetPixelFormat( Pixel::RGBA8888 );
 433       blurFilter->SetSize( mTargetSize );
 434       blurFilter->CreateKernel( BLUR_KERNEL0, sizeof(BLUR_KERNEL0)/sizeof(BLUR_KERNEL0[0]) );
 435
 436       break;
 437     }
 438     default:
 439     {
 440       break;
 441     }
 442   }
 443 }
 444 void EffectsView::AllocateResources()
 445 {
 446   if(mTargetSize != mLastSize)
 447   {
 448     mLastSize = mTargetSize;
 449
 450     SetupCameras();
 451
 452     mImageForChildren = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Dali::Image::UNUSED );
 453     mActorForChildren.SetImage(mImageForChildren);
 454
 455     mImagePostFilter = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Dali::Image::UNUSED );
 456     mActorPostFilter.SetImage(mImagePostFilter);
 457
 458     SetupFilters();
 459   }
 460 }
 461
 462 void EffectsView::SetupCameras()
 463 {
 464   const float cameraPosScale( 0.5f / tanf(ARBITRARY_FIELD_OF_VIEW * 0.5f) );
 465
 466   // Create and place a camera for the children render, corresponding to its render target size
 467   mCameraForChildren.SetFieldOfView(ARBITRARY_FIELD_OF_VIEW);
 468   // TODO: how do we pick a reasonable value for near clip? Needs to relate to normal camera the user renders with, but we don't have a handle on it
 469   mCameraForChildren.SetNearClippingPlane(1.0f);
 470   mCameraForChildren.SetAspectRatio(mTargetSize.width / mTargetSize.height);
 471   mCameraForChildren.SetType(Dali::Camera::FREE_LOOK); // camera orientation based solely on actor
 472   mCameraForChildren.SetPosition(0.0f, 0.0f, mTargetSize.height * cameraPosScale);
 473   mCameraForChildren.SetZ( mTargetSize.height * cameraPosScale );
 474 }
 475
 476 void EffectsView::CreateRenderTasks()
 477 {
 478   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 479
 480   // create render task to render our child actors to offscreen buffer
 481   mRenderTaskForChildren = taskList.CreateTask();
 482   mRenderTaskForChildren.SetRefreshRate( mRefreshOnDemand ? RenderTask::REFRESH_ONCE : RenderTask::REFRESH_ALWAYS );
 483   mRenderTaskForChildren.SetSourceActor( Self() );
 484   mRenderTaskForChildren.SetExclusive(true);
 485   mRenderTaskForChildren.SetInputEnabled( false );
 486   mRenderTaskForChildren.SetClearColor( mBackgroundColor );
 487   mRenderTaskForChildren.SetClearEnabled( true );
 488   mRenderTaskForChildren.SetTargetFrameBuffer( mImageForChildren );
 489   mRenderTaskForChildren.SetCameraActor(mCameraForChildren); // use camera that covers render target exactly
 490
 491   // Enable image filters
 492   const size_t numFilters( mFilters.size() );
 493   for( size_t i = 0; i < numFilters; ++i )
 494   {
 495     mFilters[i]->Enable();
 496   }
 497
 498   // create render task to render result of the image filters to the final offscreen
 499   if( mImageForResult )
 500   {
 501     mRenderTaskForResult = taskList.CreateTask();
 502     mRenderTaskForResult.SetRefreshRate( mRefreshOnDemand ? RenderTask::REFRESH_ONCE : RenderTask::REFRESH_ALWAYS );
 503     mRenderTaskForResult.SetSourceActor( mActorForResult );
 504     mRenderTaskForResult.SetExclusive(true);
 505     mRenderTaskForResult.SetInputEnabled( false );
 506     mRenderTaskForResult.SetClearColor( mBackgroundColor );
 507     mRenderTaskForResult.SetClearEnabled( true );
 508     mRenderTaskForResult.SetTargetFrameBuffer( mImageForResult );
 509     mRenderTaskForResult.SetCameraActor(mCameraForChildren); // use camera that covers render target exactly
 510   }
 511 }
 512
 513 void EffectsView::RemoveRenderTasks()
 514 {
 515   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 516
 517   taskList.RemoveTask(mRenderTaskForChildren);
 518   taskList.RemoveTask(mRenderTaskForResult);
 519
 520   const size_t numFilters( mFilters.size() );
 521   for( size_t i = 0; i < numFilters; ++i )
 522   {
 523     mFilters[i]->Disable();
 524   }
 525 }
 526
 527 void EffectsView::RefreshRenderTasks()
 528 {
 529   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 530
 531   if( mRenderTaskForChildren )
 532   {
 533     mRenderTaskForChildren.SetRefreshRate( mRefreshOnDemand ? RenderTask::REFRESH_ONCE : RenderTask::REFRESH_ALWAYS );
 534   }
 535
 536   if( mRenderTaskForResult )
 537   {
 538     mRenderTaskForResult.SetRefreshRate( mRefreshOnDemand ? RenderTask::REFRESH_ONCE : RenderTask::REFRESH_ALWAYS );
 539   }
 540
 541   const size_t numFilters( mFilters.size() );
 542   for( size_t i = 0; i < numFilters; ++i )
 543   {
 544     mFilters[i]->Refresh();
 545   }
 546 }
 547
 548 void EffectsView::RemoveFilters()
 549 {
 550   const size_t numFilters( mFilters.size() );
 551   for( size_t i = 0; i < numFilters; ++i )
 552   {
 553     delete mFilters[i];
 554   }
 555   mFilters.clear();
 556 }
 557
 558 } // namespace Internal
 559
 560 } // namespace Toolkit
 561
 562 } // namespace Dali