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