dali-toolkit/internal/filters/spread-filter.cpp

   1 /*
   2  * Copyright (c) 2016 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 "spread-filter.h"
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/public-api/animation/constraints.h>
  23 #include <dali/public-api/common/stage.h>
  24 #include <dali/public-api/object/property-map.h>
  25 #include <dali/public-api/render-tasks/render-task-list.h>
  26
  27 // INTERNAL INCLUDES
  28 #include <dali-toolkit/public-api/visuals/visual-properties.h>
  29
  30 namespace Dali
  31 {
  32
  33 namespace Toolkit
  34 {
  35
  36 namespace Internal
  37 {
  38
  39 namespace
  40 {
  41
  42 const char* const SPREAD_FRAGMENT_SOURCE =
  43 {
  44  "precision highp float;\n"
  45  "varying mediump vec2 vTexCoord;\n"
  46  "uniform sampler2D sTexture;\n"
  47  "uniform int uSpread;\n"
  48  "uniform vec2 uTexScale;\n"
  49  "void main()\n"
  50  "{\n"
  51  "  vec4 color = texture2D( sTexture, vTexCoord);\n"
  52  "  for( int i = 1; i <= uSpread; ++i )\n"
  53  "  {\n"
  54  "    vec2 offset = uTexScale * float(i);\n"
  55  "    color = max( texture2D( sTexture, vTexCoord + offset), color );\n"
  56  "    color = max( texture2D( sTexture, vTexCoord - offset), color );\n"
  57  "  }\n"
  58  "  gl_FragColor = color;\n"
  59  "}\n"
  60 };
  61
  62 const char* const SPREAD_UNIFORM_NAME( "uSpread" );
  63 const char* const TEX_SCALE_UNIFORM_NAME( "uTexScale" );
  64
  65 } // namespace
  66
  67
  68 SpreadFilter::SpreadFilter()
  69 : ImageFilter(),
  70   mSpread(2)
  71 {
  72 }
  73
  74 SpreadFilter::~SpreadFilter()
  75 {
  76 }
  77
  78 void SpreadFilter::SetSpread( float spread )
  79 {
  80   mSpread = spread;
  81 }
  82
  83 void SpreadFilter::Enable()
  84 {
  85   // create actor to render input with applied emboss effect
  86   mActorForInput = Toolkit::ImageView::New( mInputImage );
  87   mActorForInput.SetParentOrigin( ParentOrigin::CENTER );
  88   mActorForInput.SetSize(mTargetSize);
  89   // register properties as shader uniforms
  90   mActorForInput.RegisterProperty( SPREAD_UNIFORM_NAME, mSpread );
  91   mActorForInput.RegisterProperty( TEX_SCALE_UNIFORM_NAME, Vector2( 1.0f / mTargetSize.width, 0.0f ) );
  92
  93   // create internal offscreen for result of horizontal pass
  94   mImageForHorz = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Image::UNUSED );
  95   // create an actor to render mImageForHorz for vertical blur pass
  96   mActorForHorz = Toolkit::ImageView::New( mImageForHorz );
  97   mActorForHorz.SetParentOrigin( ParentOrigin::CENTER );
  98   mActorForHorz.SetSize(mTargetSize);
  99   // register properties as shader uniforms
 100   mActorForHorz.RegisterProperty( SPREAD_UNIFORM_NAME, mSpread );
 101   mActorForHorz.RegisterProperty( TEX_SCALE_UNIFORM_NAME, Vector2( 0.0f, 1.0f / mTargetSize.height ) );
 102
 103   Property::Map customShader;
 104   customShader[ Toolkit::Visual::Shader::Property::FRAGMENT_SHADER ] = SPREAD_FRAGMENT_SOURCE;
 105   Property::Map visualMap;
 106   visualMap.Insert( Toolkit::Visual::Property::SHADER, customShader );
 107
 108   // set SPREAD custom shader
 109   mActorForInput.SetProperty( Toolkit::ImageView::Property::IMAGE, visualMap );
 110   mActorForHorz.SetProperty( Toolkit::ImageView::Property::IMAGE, visualMap );
 111
 112   mRootActor.Add( mActorForInput );
 113   mRootActor.Add( mActorForHorz );
 114
 115   SetupCamera();
 116   CreateRenderTasks();
 117 }
 118
 119 void SpreadFilter::Disable()
 120 {
 121   if( mRootActor )
 122   {
 123     if( mCameraActor )
 124     {
 125       mRootActor.Remove( mCameraActor );
 126       mCameraActor.Reset();
 127     }
 128
 129     if( mActorForInput )
 130     {
 131       mRootActor.Remove( mActorForInput );
 132       mActorForInput.Reset();
 133     }
 134
 135     if( mActorForHorz )
 136     {
 137       mRootActor.Remove( mActorForHorz );
 138       mActorForHorz.Reset();
 139     }
 140
 141     RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 142
 143     if( mRenderTaskForHorz )
 144     {
 145       taskList.RemoveTask(mRenderTaskForHorz);
 146     }
 147     if( mRenderTaskForVert )
 148     {
 149       taskList.RemoveTask(mRenderTaskForVert);
 150     }
 151
 152     mRootActor.Reset();
 153   }
 154 }
 155
 156 void SpreadFilter::Refresh()
 157 {
 158   if( mRenderTaskForHorz )
 159   {
 160     mRenderTaskForHorz.SetRefreshRate( mRefreshOnDemand ? RenderTask::REFRESH_ONCE : RenderTask::REFRESH_ALWAYS );
 161   }
 162
 163   if( mRenderTaskForVert )
 164   {
 165     mRenderTaskForVert.SetRefreshRate( mRefreshOnDemand ? RenderTask::REFRESH_ONCE : RenderTask::REFRESH_ALWAYS );
 166   }
 167 }
 168
 169 void SpreadFilter::SetSize( const Vector2& size )
 170 {
 171   mTargetSize = size;
 172   if( mActorForInput )
 173   {
 174     mActorForInput.SetSize(mTargetSize);
 175   }
 176   if( mActorForHorz )
 177   {
 178     mActorForHorz.SetSize(mTargetSize);
 179   }
 180 }
 181
 182 void SpreadFilter::CreateRenderTasks()
 183 {
 184   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 185
 186   // perform a horizontal blur targeting the internal buffer
 187   mRenderTaskForHorz = taskList.CreateTask();
 188   mRenderTaskForHorz.SetRefreshRate( mRefreshOnDemand ? RenderTask::REFRESH_ONCE : RenderTask::REFRESH_ALWAYS );
 189   mRenderTaskForHorz.SetSourceActor( mActorForInput );
 190   mRenderTaskForHorz.SetExclusive(true);
 191   mRenderTaskForHorz.SetInputEnabled( false );
 192   mRenderTaskForHorz.SetClearEnabled( true );
 193   mRenderTaskForHorz.SetClearColor( mBackgroundColor );
 194   mRenderTaskForHorz.SetTargetFrameBuffer( mImageForHorz );
 195   mRenderTaskForHorz.SetCameraActor( mCameraActor );
 196
 197   // use the internal buffer and perform a horizontal blur targeting the output buffer
 198   mRenderTaskForVert = taskList.CreateTask();
 199   mRenderTaskForVert.SetRefreshRate( mRefreshOnDemand ? RenderTask::REFRESH_ONCE : RenderTask::REFRESH_ALWAYS );
 200   mRenderTaskForVert.SetSourceActor( mActorForHorz );
 201   mRenderTaskForVert.SetExclusive(true);
 202   mRenderTaskForVert.SetInputEnabled( false );
 203   mRenderTaskForVert.SetClearEnabled( true );
 204   mRenderTaskForVert.SetClearColor( mBackgroundColor );
 205   mRenderTaskForVert.SetTargetFrameBuffer( mOutputImage );
 206   mRenderTaskForVert.SetCameraActor( mCameraActor );
 207 }
 208
 209 } // namespace Internal
 210
 211 } // namespace Toolkit
 212
 213 } // namespace Dali