dali-toolkit/internal/filters/blur-two-pass-filter.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 "blur-two-pass-filter.h"
  20
  21 // EXTERNAL INCLUDES
  22 #include <sstream>
  23 #include <dali/public-api/animation/constraints.h>
  24 #include <dali/public-api/common/stage.h>
  25 #include <dali/public-api/render-tasks/render-task-list.h>
  26
  27 // INTERNAL INCLUDES
  28
  29 namespace Dali
  30 {
  31
  32 namespace Toolkit
  33 {
  34
  35 namespace Internal
  36 {
  37
  38 namespace
  39 {
  40
  41 const float DEFAULT_KERNEL0[] = { 12.0f/16.0f, 2.0f/16.0f, 2.0f/16.0f };
  42
  43 const float DEFAULT_KERNEL1[] = { 8.0f/16.0f, 2.75f/16.0f, 2.75f/16.0f, 1.25f/16.0f,
  44                                   1.25f/16.0f };
  45
  46 const float DEFAULT_KERNEL2[] = { 5.0f/16.0f, 2.75f/16.0f, 2.75f/16.0f, 1.75f/16.0f,
  47                                   1.75f/16.0f, 1.5f/16.0f, 1.5f/16.0f };
  48
  49 const float DEFAULT_KERNEL3[] = { 3.0f/16.0f, 2.0f/16.0f, 2.0f/16.0f, 2.0f/16.0f,
  50                                   2.0f/16.0f, 2.0f/16.0f, 2.0f/16.0f, 0.5f/16.0f,
  51                                   0.5f/16.0f };
  52
  53 const float DEFAULT_KERNEL4[] = { 2.0f/16.0f, 1.5f/16.0f, 1.5f/16.0f, 1.5f/16.0f,
  54                                   1.5f/16.0f, 1.0f/16.0f, 1.0f/16.0f, 1.0f/16.0f,
  55                                   1.0f/16.0f, 1.0f/16.0f, 1.0f/16.0f, 0.5f/16.0f,
  56                                   0.5f/16.0f, 0.5f/16.0f, 0.5f/16.0f };
  57
  58
  59 const float ARBITRARY_FIELD_OF_VIEW = Math::PI / 4.0f;
  60
  61 const char* BLUR_TWO_PASS_FRAGMENT_SOURCE =
  62 {
  63  "precision highp float;\n"
  64  "uniform vec2 uSampleOffsets[NUM_SAMPLES];\n"
  65  "uniform float uSampleWeights[NUM_SAMPLES];\n"
  66  "void main()\n"
  67  "{\n"
  68  "  vec4 color = vec4(0.0);\n"
  69  "# ifdef DEBUG_RENDER\n"
  70  "  if( vTexCoord.s < 0.495 )\n"
  71  "  {\n"
  72  "# endif //def DEBUG_RENDER\n"
  73  "    for( int i = 0; i < NUM_SAMPLES; ++i )\n"
  74  "    {\n"
  75  "      color += texture2D( sTexture, vTexCoord + uSampleOffsets[i] ) * uSampleWeights[i];\n"
  76  "    }\n"
  77  "# ifdef DEBUG_RENDER\n"
  78  "  }\n"
  79  "  else if( vTexCoord.s > 0.505 )\n"
  80  "  {\n"
  81  "    color = texture2D( sTexture, vTexCoord );\n"
  82  "  }\n"
  83  "  else\n"
  84  "  {\n"
  85  "    color = vec4( 1.0, 0.0, 0.0, 1.0 );\n"
  86  "  }\n"
  87  "# endif //def DEBUG_RENDER\n"
  88  "  gl_FragColor = color;\n"
  89  "}\n"
  90 };
  91
  92 std::string GetOffsetUniformName( int index )
  93 {
  94   std::ostringstream oss;
  95   oss << "uSampleOffsets[" << index << "]";
  96   return oss.str();
  97 }
  98
  99 std::string GetWeightUniformName( int index )
 100 {
 101   std::ostringstream oss;
 102   oss << "uSampleWeights[" << index << "]";
 103   return oss.str();
 104 }
 105
 106 const char* BLEND_TWO_IMAGES_FRAGMENT_SOURCE =
 107 {
 108  "precision highp float;\n"
 109  "uniform float uBlurStrength; \n "
 110  "void main()\n"
 111  "{\n"
 112  "  gl_FragColor = texture2D( sTexture, vTexCoord ) * uBlurStrength"
 113  "               + texture2D( sEffect, vTexCoord )*(1.0-uBlurStrength); \n"
 114  "}\n"
 115 };
 116
 117 std::string GetBlurStrengthUniformName()
 118 {
 119   return "uBlurStrength";
 120 }
 121
 122 } // namespace
 123
 124
 125 BlurTwoPassFilter::BlurTwoPassFilter()
 126 : ImageFilter()
 127 {
 128   mShaderForBlending = ShaderEffect::New( "", BLEND_TWO_IMAGES_FRAGMENT_SOURCE );
 129   mShaderForBlending.SetUniform( GetBlurStrengthUniformName(), 1.f );
 130   mBlurStrengthPropertyIndex = mShaderForBlending.GetPropertyIndex( GetBlurStrengthUniformName() );
 131 }
 132
 133 BlurTwoPassFilter::~BlurTwoPassFilter()
 134 {
 135 }
 136
 137 void BlurTwoPassFilter::Enable()
 138 {
 139   mCameraForBlur = CameraActor::New();
 140   mCameraForBlur.SetParentOrigin(ParentOrigin::CENTER);
 141
 142   // create actor to render input with applied emboss effect
 143   mActorForInput = ImageActor::New( mInputImage );
 144   mActorForInput.SetParentOrigin( ParentOrigin::CENTER );
 145   mActorForInput.SetSize( mTargetSize );
 146   mActorForInput.ScaleBy( Vector3(1.0f, -1.0f, 1.0f) );
 147
 148   // create internal offscreen for result of horizontal pass
 149   mImageForHorz = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Image::UNUSED );
 150
 151   // create an actor to render mImageForHorz for vertical blur pass
 152   mActorForHorz = ImageActor::New( mImageForHorz );
 153   mActorForHorz.SetParentOrigin( ParentOrigin::CENTER );
 154   mActorForHorz.SetSize( mTargetSize );
 155   mActorForHorz.ScaleBy( Vector3(1.0f, -1.0f, 1.0f) );
 156
 157   // create internal offscreen for result of the two pass blurred image
 158   mBlurredImage = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Image::UNUSED);
 159
 160   // create an actor to blend the blurred image and the input image with the given blur strength
 161   mActorForBlending = ImageActor::New( mBlurredImage );
 162   mActorForBlending.SetParentOrigin( ParentOrigin::CENTER );
 163   mActorForBlending.SetSize( mTargetSize );
 164   mActorForBlending.ScaleBy( Vector3(1.0f, -1.0f, 1.0f) );
 165
 166   mRootActor.Add( mActorForInput );
 167   mRootActor.Add( mActorForHorz );
 168   mRootActor.Add( mActorForBlending );
 169   mRootActor.Add( mCameraForBlur );
 170
 171   // create custom shader effect
 172   if( !GetKernelSize() )
 173   {
 174     CreateKernel( DEFAULT_KERNEL4, sizeof(DEFAULT_KERNEL4)/sizeof(DEFAULT_KERNEL4[0]) );
 175   }
 176   int kernelSize( static_cast< int >(GetKernelSize()) );
 177
 178   std::ostringstream fragmentSource;
 179   if( mDebugRender )
 180   {
 181     fragmentSource << "#define DEBUG_RENDER\n";
 182   }
 183   fragmentSource << "#define NUM_SAMPLES " << kernelSize << "\n";
 184   fragmentSource << BLUR_TWO_PASS_FRAGMENT_SOURCE;
 185   mShaderForHorz = ShaderEffect::New( "", fragmentSource.str() );
 186   mActorForInput.SetShaderEffect( mShaderForHorz );
 187   mShaderForVert = ShaderEffect::New( "", fragmentSource.str() );
 188   mActorForHorz.SetShaderEffect( mShaderForVert );
 189
 190   for( int i = 0; i < kernelSize; ++i )
 191   {
 192     const std::string offsetUniform( GetOffsetUniformName( i ) );
 193     const std::string weightUniform( GetWeightUniformName( i ) );
 194
 195     mShaderForHorz.SetUniform( offsetUniform, Vector2(mKernel[i]) * Vector2::XAXIS );
 196     mShaderForHorz.SetUniform( weightUniform, mKernel[i].z );
 197
 198     mShaderForVert.SetUniform( offsetUniform, Vector2(mKernel[i]) * Vector2::YAXIS );
 199     mShaderForVert.SetUniform( weightUniform, mKernel[i].z );
 200   }
 201
 202   mActorForBlending.SetShaderEffect( mShaderForBlending );
 203   mShaderForBlending.SetEffectImage( mInputImage );
 204
 205   SetupCamera();
 206   CreateRenderTasks();
 207 }
 208
 209 void BlurTwoPassFilter::Disable()
 210 {
 211   if( mRootActor )
 212   {
 213     if( mCameraForBlur )
 214     {
 215       mRootActor.Remove( mCameraForBlur );
 216       mCameraForBlur.Reset();
 217     }
 218
 219     if( mActorForInput )
 220     {
 221       mRootActor.Remove( mActorForInput );
 222       mActorForInput.Reset();
 223     }
 224
 225     if( mActorForHorz )
 226     {
 227       mRootActor.Remove( mActorForHorz );
 228       mActorForHorz.Reset();
 229     }
 230
 231     if( mActorForBlending )
 232     {
 233       mRootActor.Remove( mActorForBlending );
 234       mActorForBlending.Reset();
 235     }
 236
 237     RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 238
 239     if( mRenderTaskForHorz )
 240     {
 241       taskList.RemoveTask(mRenderTaskForHorz);
 242     }
 243     if( mRenderTaskForVert )
 244     {
 245       taskList.RemoveTask(mRenderTaskForVert);
 246     }
 247     if( mRenderTaskForBlending )
 248     {
 249       taskList.RemoveTask(mRenderTaskForBlending);
 250     }
 251
 252     mRootActor.Reset();
 253   }
 254 }
 255
 256 void BlurTwoPassFilter::Refresh()
 257 {
 258   if( mRenderTaskForHorz )
 259   {
 260     mRenderTaskForHorz.SetRefreshRate( mRefreshOnDemand ? RenderTask::REFRESH_ONCE : RenderTask::REFRESH_ALWAYS );
 261   }
 262
 263   if( mRenderTaskForVert )
 264   {
 265     mRenderTaskForVert.SetRefreshRate( mRefreshOnDemand ? RenderTask::REFRESH_ONCE : RenderTask::REFRESH_ALWAYS );
 266   }
 267
 268   if( mRenderTaskForBlending )
 269   {
 270     mRenderTaskForBlending.SetRefreshRate( mRefreshOnDemand ? RenderTask::REFRESH_ONCE : RenderTask::REFRESH_ALWAYS );
 271   }
 272 }
 273
 274 void BlurTwoPassFilter::SetSize( const Vector2& size )
 275 {
 276   mTargetSize = size;
 277   if( mActorForInput )
 278   {
 279     mActorForInput.SetSize(mTargetSize);
 280   }
 281   if( mActorForHorz )
 282   {
 283     mActorForHorz.SetSize(mTargetSize);
 284   }
 285   if( mActorForBlending )
 286   {
 287     mActorForBlending.SetSize(mTargetSize);
 288   }
 289 }
 290
 291 Handle BlurTwoPassFilter::GetHandleForAnimateBlurStrength()
 292 {
 293   return mShaderForBlending;
 294 }
 295
 296 void BlurTwoPassFilter::SetupCamera()
 297 {
 298   // Create and place a camera for the embossing render, corresponding to its render target size
 299   mCameraForBlur.SetFieldOfView(ARBITRARY_FIELD_OF_VIEW);
 300   mCameraForBlur.SetNearClippingPlane(1.0f);
 301   mCameraForBlur.SetAspectRatio(mTargetSize.width / mTargetSize.height);
 302   mCameraForBlur.SetType(Dali::Camera::FREE_LOOK); // camera orientation based solely on actor
 303   mCameraForBlur.SetPosition(0.0f, 0.0f, ((mTargetSize.height * 0.5f) / tanf(ARBITRARY_FIELD_OF_VIEW * 0.5f)));
 304 }
 305
 306 void BlurTwoPassFilter::CreateRenderTasks()
 307 {
 308   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 309
 310   // perform a horizontal blur targeting the internal buffer
 311   mRenderTaskForHorz = taskList.CreateTask();
 312   mRenderTaskForHorz.SetRefreshRate( mRefreshOnDemand ? RenderTask::REFRESH_ONCE : RenderTask::REFRESH_ALWAYS );
 313   mRenderTaskForHorz.SetSourceActor( mActorForInput );
 314   mRenderTaskForHorz.SetExclusive(true);
 315   mRenderTaskForHorz.SetInputEnabled( false );
 316   mRenderTaskForHorz.SetClearEnabled( true );
 317   mRenderTaskForHorz.SetClearColor( mBackgroundColor );
 318   mRenderTaskForHorz.SetTargetFrameBuffer( mImageForHorz );
 319   mRenderTaskForHorz.SetCameraActor( mCameraForBlur );
 320
 321   // use the internal buffer and perform a horizontal blur targeting the output buffer
 322   mRenderTaskForVert = taskList.CreateTask();
 323   mRenderTaskForVert.SetRefreshRate( mRefreshOnDemand ? RenderTask::REFRESH_ONCE : RenderTask::REFRESH_ALWAYS );
 324   mRenderTaskForVert.SetSourceActor( mActorForHorz );
 325   mRenderTaskForVert.SetExclusive(true);
 326   mRenderTaskForVert.SetInputEnabled( false );
 327   mRenderTaskForVert.SetClearEnabled( true );
 328   mRenderTaskForVert.SetClearColor( mBackgroundColor );
 329   mRenderTaskForVert.SetTargetFrameBuffer( mBlurredImage );
 330   mRenderTaskForVert.SetCameraActor( mCameraForBlur );
 331
 332   //Perform a blending between the blurred image and the input image
 333   mRenderTaskForBlending = taskList.CreateTask();
 334   mRenderTaskForBlending.SetRefreshRate( mRefreshOnDemand ? RenderTask::REFRESH_ONCE : RenderTask::REFRESH_ALWAYS );
 335   mRenderTaskForBlending.SetSourceActor( mActorForBlending );
 336   mRenderTaskForBlending.SetExclusive(true);
 337   mRenderTaskForBlending.SetInputEnabled( false );
 338   mRenderTaskForBlending.SetClearEnabled( true );
 339   mRenderTaskForBlending.SetClearColor( mBackgroundColor );
 340   mRenderTaskForBlending.SetTargetFrameBuffer( mOutputImage );
 341   mRenderTaskForBlending.SetCameraActor( mCameraForBlur );
 342 }
 343
 344 } // namespace Internal
 345
 346 } // namespace Toolkit
 347
 348 } // namespace Dali