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

   1 /*
   2  * Copyright (c) 2017 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/internal/controls/control/control-renderers.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 = Actor::New();
  87   mActorForInput.SetProperty( Actor::Property::PARENT_ORIGIN, 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   Renderer rendererForInput = CreateRenderer( BASIC_VERTEX_SOURCE, SPREAD_FRAGMENT_SOURCE );
  94   SetRendererTexture( rendererForInput, mInputTexture );
  95   mActorForInput.AddRenderer( rendererForInput );
  96
  97   // create internal offscreen for result of horizontal pass
  98   mFrameBufferForHorz = FrameBuffer::New( mTargetSize.width, mTargetSize.height, FrameBuffer::Attachment::NONE );
  99   Texture textureForHorz = Texture::New( TextureType::TEXTURE_2D, mPixelFormat, unsigned(mTargetSize.width), unsigned(mTargetSize.height) );
 100   mFrameBufferForHorz.AttachColorTexture( textureForHorz );
 101
 102   // create an actor to render mImageForHorz for vertical blur pass
 103   mActorForHorz = Actor::New();
 104   mActorForHorz.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
 105   mActorForHorz.SetSize(mTargetSize);
 106   // register properties as shader uniforms
 107   mActorForHorz.RegisterProperty( SPREAD_UNIFORM_NAME, mSpread );
 108   mActorForHorz.RegisterProperty( TEX_SCALE_UNIFORM_NAME, Vector2( 0.0f, 1.0f / mTargetSize.height ) );
 109   Renderer rendererForHorz = CreateRenderer( BASIC_VERTEX_SOURCE, SPREAD_FRAGMENT_SOURCE );
 110   SetRendererTexture( rendererForHorz, textureForHorz );
 111   mActorForHorz.AddRenderer( rendererForHorz );
 112
 113   mRootActor.Add( mActorForInput );
 114   mRootActor.Add( mActorForHorz );
 115
 116   SetupCamera();
 117   CreateRenderTasks();
 118 }
 119
 120 void SpreadFilter::Disable()
 121 {
 122   if( mRootActor )
 123   {
 124     if( mCameraActor )
 125     {
 126       mRootActor.Remove( mCameraActor );
 127       mCameraActor.Reset();
 128     }
 129
 130     if( mActorForInput )
 131     {
 132       mRootActor.Remove( mActorForInput );
 133       mActorForInput.Reset();
 134     }
 135
 136     if( mActorForHorz )
 137     {
 138       mRootActor.Remove( mActorForHorz );
 139       mActorForHorz.Reset();
 140     }
 141
 142     RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 143
 144     if( mRenderTaskForHorz )
 145     {
 146       taskList.RemoveTask(mRenderTaskForHorz);
 147     }
 148     if( mRenderTaskForVert )
 149     {
 150       taskList.RemoveTask(mRenderTaskForVert);
 151     }
 152
 153     mRootActor.Reset();
 154   }
 155 }
 156
 157 void SpreadFilter::Refresh()
 158 {
 159   if( mRenderTaskForHorz )
 160   {
 161     mRenderTaskForHorz.SetRefreshRate( mRefreshOnDemand ? RenderTask::REFRESH_ONCE : RenderTask::REFRESH_ALWAYS );
 162   }
 163
 164   if( mRenderTaskForVert )
 165   {
 166     mRenderTaskForVert.SetRefreshRate( mRefreshOnDemand ? RenderTask::REFRESH_ONCE : RenderTask::REFRESH_ALWAYS );
 167   }
 168 }
 169
 170 void SpreadFilter::SetSize( const Vector2& size )
 171 {
 172   mTargetSize = size;
 173   if( mActorForInput )
 174   {
 175     mActorForInput.SetSize(mTargetSize);
 176   }
 177   if( mActorForHorz )
 178   {
 179     mActorForHorz.SetSize(mTargetSize);
 180   }
 181 }
 182
 183 void SpreadFilter::CreateRenderTasks()
 184 {
 185   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 186
 187   // perform a horizontal blur targeting the internal buffer
 188   mRenderTaskForHorz = taskList.CreateTask();
 189   mRenderTaskForHorz.SetRefreshRate( mRefreshOnDemand ? RenderTask::REFRESH_ONCE : RenderTask::REFRESH_ALWAYS );
 190   mRenderTaskForHorz.SetSourceActor( mActorForInput );
 191   mRenderTaskForHorz.SetExclusive(true);
 192   mRenderTaskForHorz.SetInputEnabled( false );
 193   mRenderTaskForHorz.SetClearEnabled( true );
 194   mRenderTaskForHorz.SetClearColor( mBackgroundColor );
 195   mRenderTaskForHorz.SetFrameBuffer( mFrameBufferForHorz );
 196   mRenderTaskForHorz.SetCameraActor( mCameraActor );
 197
 198   // use the internal buffer and perform a horizontal blur targeting the output buffer
 199   mRenderTaskForVert = taskList.CreateTask();
 200   mRenderTaskForVert.SetRefreshRate( mRefreshOnDemand ? RenderTask::REFRESH_ONCE : RenderTask::REFRESH_ALWAYS );
 201   mRenderTaskForVert.SetSourceActor( mActorForHorz );
 202   mRenderTaskForVert.SetExclusive(true);
 203   mRenderTaskForVert.SetInputEnabled( false );
 204   mRenderTaskForVert.SetClearEnabled( true );
 205   mRenderTaskForVert.SetClearColor( mBackgroundColor );
 206   mRenderTaskForVert.SetFrameBuffer( mOutputFrameBuffer );
 207   mRenderTaskForVert.SetCameraActor( mCameraActor );
 208 }
 209
 210 } // namespace Internal
 211
 212 } // namespace Toolkit
 213
 214 } // namespace Dali