Add 'ExclusiveArch: armv7l' limit build to arm architecture
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / controls / gaussian-blur-view / gaussian-blur-view-impl.cpp
1 //
2 // Copyright (c) 2014 Samsung Electronics Co., Ltd.
3 //
4 // Licensed under the Flora License, Version 1.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://floralicense.org/license/
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 // CLASS HEADER
18 #include "gaussian-blur-view-impl.h"
19
20 // EXTERNAL INCLUDES
21 #include <sstream>
22 #include <iomanip>
23
24 // INTERNAL INCLUDES
25 #include <dali-toolkit/public-api/controls/gaussian-blur-view/gaussian-blur-view.h>
26
27 #include <dali/integration-api/debug.h>
28
29 // TODO:
30 // pixel format / size - set from JSON
31 // aspect ratio property needs to be able to be constrained also for cameras, not possible currently. Therefore changing aspect ratio of GaussianBlurView won't currently work
32 // default near clip value
33 // mChildrenRoot Add()/Remove() overloads - better solution
34 // Manager object - re-use render targets if there are multiple GaussianBlurViews created
35
36
37
38 /////////////////////////////////////////////////////////
39 // IMPLEMENTATION NOTES
40
41 // As the GaussianBlurView actor changes size, the amount of pixels we need to blur changes. Therefore we need some way of doing this. However:-
42 // OnSetSize() does not get called when GaussianBlurView object size is modified using a Constraint.
43 // OnSizeAnimation() only gets called once per AnimateTo/By() and if an Animation has N such calls then only the final one will end up being used. Therefore we can't use
44 // OnSizeAnimation() to alter render target sizes.
45 // To get around the above problems, we use fixed sized render targets, from the last SetSize() call (which calls OnSetSize()), then we adjust the internal cameras / actors
46 // to take account of the changed GaussianBlurView object size, projecting to the unchanged render target sizes. This is done relative to the fixed render target / actor sizes
47 // by using constraints relative to the GaussianBlurView actor size.
48
49
50 // 2 modes:
51 // 1st mode, this control has a tree of actors (use Add() to add children) that are rendered and blurred.
52 // mRenderChildrenTask renders children to FB mRenderTargetForRenderingChildren
53 // mHorizBlurTask renders mImageActorHorizBlur Actor showing FB mRenderTargetForRenderingChildren into FB mRenderTarget2
54 // mVertBlurTask renders mImageActorVertBlur Actor showing FB mRenderTarget2 into FB mRenderTarget1
55 // mCompositeTask renders mImageActorComposite Actor showing FB mRenderTarget1 into FB mRenderTargetForRenderingChildren
56 //
57 // 2nd mode, an image is blurred and rendered to a supplied target framebuffer
58 // mHorizBlurTask renders mImageActorHorizBlur Actor showing mUserInputImage into FB mRenderTarget2
59 // mVertBlurTask renders mImageActorVertBlur Actor showing mRenderTarget2 into FB mUserOutputRenderTarget
60 //
61 // Only this 2nd mode handles ActivateOnce
62
63 namespace Dali
64 {
65
66 namespace Toolkit
67 {
68
69 namespace Internal
70 {
71
72 namespace
73 {
74
75 using namespace Dali;
76
77 BaseHandle Create()
78 {
79   return Toolkit::GaussianBlurView::New();
80 }
81
82 TypeRegistration mType( typeid(Toolkit::GaussianBlurView), typeid(Toolkit::Control), Create );
83
84
85 const unsigned int GAUSSIAN_BLUR_VIEW_DEFAULT_NUM_SAMPLES = 5;
86 const float GAUSSIAN_BLUR_VIEW_DEFAULT_BLUR_BELL_CURVE_WIDTH = 1.5f;
87 const Pixel::Format GAUSSIAN_BLUR_VIEW_DEFAULT_RENDER_TARGET_PIXEL_FORMAT = Pixel::RGBA8888;
88 const float GAUSSIAN_BLUR_VIEW_DEFAULT_BLUR_STRENGTH = 1.0f;                                       // default, fully blurred
89 const std::string GAUSSIAN_BLUR_VIEW_STRENGTH_PROPERTY_NAME("GaussianBlurStrengthPropertyName");
90 const float GAUSSIAN_BLUR_VIEW_DEFAULT_DOWNSAMPLE_WIDTH_SCALE = 0.5f;
91 const float GAUSSIAN_BLUR_VIEW_DEFAULT_DOWNSAMPLE_HEIGHT_SCALE = 0.5f;
92
93 const float ARBITRARY_FIELD_OF_VIEW = Math::PI / 4.0f;
94
95 const char* const GAUSSIAN_BLUR_FRAGMENT_SOURCE =
96     "uniform vec2 uSampleOffsets[NUM_SAMPLES];\n"
97     "uniform float uSampleWeights[NUM_SAMPLES];\n"
98
99     "void main()\n"
100     "{\n"
101     "   mediump vec4 col;\n"
102     "   col = texture2D(sTexture, vec2(vTexCoord.x, vTexCoord.y) + uSampleOffsets[0]) * uSampleWeights[0];     \n"
103     "   for (int i=1; i<NUM_SAMPLES; ++i)                                                                      \n"
104     "   {                                                                                                      \n"
105     "     col += texture2D(sTexture, vec2(vTexCoord.x, vTexCoord.y) + uSampleOffsets[i]) * uSampleWeights[i];  \n"
106     "   }                                                                                                      \n"
107     "   gl_FragColor = col;\n"
108     "}\n";
109
110 } // namespace
111
112
113 GaussianBlurView::GaussianBlurView()
114   : ControlImpl( false )  // doesn't require touch events
115   , mNumSamples(GAUSSIAN_BLUR_VIEW_DEFAULT_NUM_SAMPLES)
116
117   , mPixelFormat(GAUSSIAN_BLUR_VIEW_DEFAULT_RENDER_TARGET_PIXEL_FORMAT)
118   , mDownsampleWidthScale(GAUSSIAN_BLUR_VIEW_DEFAULT_DOWNSAMPLE_WIDTH_SCALE)
119   , mDownsampleHeightScale(GAUSSIAN_BLUR_VIEW_DEFAULT_DOWNSAMPLE_HEIGHT_SCALE)
120   , mDownsampledWidth( 0.0f )
121   , mDownsampledHeight( 0.0f )
122   , mBlurUserImage( false )
123   , mBackgroundColor( Color::BLACK )
124   , mTargetSize(Vector2::ZERO)
125   , mLastSize(Vector2::ZERO)
126   , mChildrenRoot(Actor::New())
127   , mBlurStrengthPropertyIndex(Property::INVALID_INDEX)
128 {
129   SetBlurBellCurveWidth(GAUSSIAN_BLUR_VIEW_DEFAULT_BLUR_BELL_CURVE_WIDTH);
130 }
131
132 GaussianBlurView::GaussianBlurView( const unsigned int numSamples, const float blurBellCurveWidth, const Pixel::Format renderTargetPixelFormat,
133                                     const float downsampleWidthScale, const float downsampleHeightScale,
134                                     bool blurUserImage)
135   : ControlImpl( false )  // doesn't require touch events
136   , mNumSamples(numSamples)
137   , mPixelFormat(renderTargetPixelFormat)
138   , mDownsampleWidthScale(downsampleWidthScale)
139   , mDownsampleHeightScale(downsampleHeightScale)
140   , mDownsampledWidth( 0.0f )
141   , mDownsampledHeight( 0.0f )
142   , mBlurUserImage( blurUserImage )
143   , mBackgroundColor( Color::BLACK )
144   , mTargetSize(Vector2::ZERO)
145   , mLastSize(Vector2::ZERO)
146   , mChildrenRoot(Actor::New())
147   , mBlurStrengthPropertyIndex(Property::INVALID_INDEX)
148 {
149   SetBlurBellCurveWidth(blurBellCurveWidth);
150 }
151
152 GaussianBlurView::~GaussianBlurView()
153 {
154 }
155
156
157 Toolkit::GaussianBlurView GaussianBlurView::New()
158 {
159   GaussianBlurView* impl = new GaussianBlurView();
160
161   Dali::Toolkit::GaussianBlurView handle = Dali::Toolkit::GaussianBlurView( *impl );
162
163   // Second-phase init of the implementation
164   // This can only be done after the CustomActor connection has been made...
165   impl->Initialize();
166
167   return handle;
168 }
169
170 Toolkit::GaussianBlurView GaussianBlurView::New(const unsigned int numSamples, const float blurBellCurveWidth, const Pixel::Format renderTargetPixelFormat,
171                                                 const float downsampleWidthScale, const float downsampleHeightScale,
172                                                 bool blurUserImage)
173 {
174   GaussianBlurView* impl = new GaussianBlurView( numSamples, blurBellCurveWidth, renderTargetPixelFormat,
175                                                  downsampleWidthScale, downsampleHeightScale,
176                                                  blurUserImage);
177
178   Dali::Toolkit::GaussianBlurView handle = Dali::Toolkit::GaussianBlurView( *impl );
179
180   // Second-phase init of the implementation
181   // This can only be done after the CustomActor connection has been made...
182   impl->Initialize();
183
184   return handle;
185 }
186
187 /////////////////////////////////////////////////////////////
188 // for creating a subtree for all user added child actors, so that we can have them exclusive to the mRenderChildrenTask and our other actors exclusive to our other tasks
189 // TODO: overloading Actor::Add()/Remove() not nice since breaks polymorphism. Need another method to pass ownership of added child actors to our internal actor root.
190 void GaussianBlurView::Add(Actor child)
191 {
192   mChildrenRoot.Add(child);
193 }
194
195 void GaussianBlurView::Remove(Actor child)
196 {
197   mChildrenRoot.Remove(child);
198 }
199
200 void GaussianBlurView::SetUserImageAndOutputRenderTarget(Image inputImage, FrameBufferImage outputRenderTarget)
201 {
202   // can only do this if the GaussianBlurView object was created with this parameter set
203   DALI_ASSERT_ALWAYS(mBlurUserImage);
204
205   mUserInputImage = inputImage;
206   mImageActorHorizBlur.SetImage( mUserInputImage );
207
208   mUserOutputRenderTarget = outputRenderTarget;
209 }
210
211 FrameBufferImage GaussianBlurView::GetBlurredRenderTarget() const
212 {
213   if(!mUserOutputRenderTarget)
214   {
215     return mRenderTargetForRenderingChildren;
216   }
217
218   return mUserOutputRenderTarget;
219 }
220
221 void GaussianBlurView::SetBackgroundColor( const Vector4& color )
222 {
223   mBackgroundColor = color;
224 }
225
226 Vector4 GaussianBlurView::GetBackgroundColor() const
227 {
228   return mBackgroundColor;
229 }
230
231 ///////////////////////////////////////////////////////////
232 //
233 // Private methods
234 //
235
236 /**
237  * EqualToConstraintFloat
238  *
239  * f(current, property) = property
240  */
241 struct EqualToConstraintFloat
242 {
243   EqualToConstraintFloat(){}
244
245   float operator()(const float current, const PropertyInput& property) {return property.GetFloat();}
246 };
247
248 void GaussianBlurView::OnInitialize()
249 {
250   // root actor to parent all user added actors, needed to allow us to set that subtree as exclusive for our child render task
251   mChildrenRoot.SetParentOrigin(ParentOrigin::CENTER);
252   mChildrenRoot.ApplyConstraint( Constraint::New<Vector3>( Actor::SIZE, ParentSource( Actor::SIZE ), EqualToConstraint() ) ); // same size as GaussianBlurView object
253
254
255   //////////////////////////////////////////////////////
256   // Create shaders
257
258   // horiz
259   std::ostringstream horizFragmentShaderStringStream;
260   horizFragmentShaderStringStream << "#define NUM_SAMPLES " << mNumSamples << "\n";
261   horizFragmentShaderStringStream << GAUSSIAN_BLUR_FRAGMENT_SOURCE;
262   mHorizBlurShader = ShaderEffect::New( "", horizFragmentShaderStringStream.str() );
263   // vert
264   std::ostringstream vertFragmentShaderStringStream;
265   vertFragmentShaderStringStream << "#define NUM_SAMPLES " << mNumSamples << "\n";
266   vertFragmentShaderStringStream << GAUSSIAN_BLUR_FRAGMENT_SOURCE;
267   mVertBlurShader = ShaderEffect::New( "", vertFragmentShaderStringStream.str() );
268
269
270   //////////////////////////////////////////////////////
271   // Create actors
272
273   // Create an ImageActor for performing a horizontal blur on the texture
274   mImageActorHorizBlur = ImageActor::New();
275   mImageActorHorizBlur.SetParentOrigin(ParentOrigin::CENTER);
276   mImageActorHorizBlur.ScaleBy( Vector3(1.0f, -1.0f, 1.0f) ); // FIXME
277   mImageActorHorizBlur.SetShaderEffect( mHorizBlurShader );
278
279   // Create an ImageActor for performing a vertical blur on the texture
280   mImageActorVertBlur = ImageActor::New();
281   mImageActorVertBlur.SetParentOrigin(ParentOrigin::CENTER);
282   mImageActorVertBlur.ScaleBy( Vector3(1.0f, -1.0f, 1.0f) ); // FIXME
283   mImageActorVertBlur.SetShaderEffect( mVertBlurShader );
284
285   // Register a property that the user can control to fade the blur in / out via the GaussianBlurView object
286   mBlurStrengthPropertyIndex = Self().RegisterProperty(GAUSSIAN_BLUR_VIEW_STRENGTH_PROPERTY_NAME, GAUSSIAN_BLUR_VIEW_DEFAULT_BLUR_STRENGTH);
287
288   // Create an ImageActor for compositing the blur and the original child actors render
289   if(!mBlurUserImage)
290   {
291     mImageActorComposite = ImageActor::New();
292     mImageActorComposite.SetParentOrigin(ParentOrigin::CENTER);
293     mImageActorComposite.ApplyConstraint( Constraint::New<Vector3>( Actor::SIZE, ParentSource( Actor::SIZE ), EqualToConstraint() ) ); // same size as GaussianBlurView object
294     mImageActorComposite.ScaleBy( Vector3(1.0f, -1.0f, 1.0f) ); // FIXME
295     mImageActorComposite.SetOpacity(GAUSSIAN_BLUR_VIEW_DEFAULT_BLUR_STRENGTH); // ensure alpha is enabled for this object and set default value
296
297     Constraint blurStrengthConstraint = Constraint::New<float>( Actor::COLOR_ALPHA, ParentSource(mBlurStrengthPropertyIndex), EqualToConstraintFloat());
298     mImageActorComposite.ApplyConstraint(blurStrengthConstraint);
299
300     // Create an ImageActor for holding final result, i.e. the blurred image. This will get rendered to screen later, via default / user render task
301     mTargetActor = ImageActor::New();
302     mTargetActor.SetParentOrigin(ParentOrigin::CENTER);
303     mTargetActor.ApplyConstraint( Constraint::New<Vector3>( Actor::SIZE, ParentSource( Actor::SIZE ), EqualToConstraint() ) ); // same size as GaussianBlurView object
304     mTargetActor.ScaleBy( Vector3(1.0f, -1.0f, 1.0f) ); // FIXME
305
306
307     //////////////////////////////////////////////////////
308     // Create cameras for the renders corresponding to the view size
309     mRenderFullSizeCamera = CameraActor::New();
310     mRenderFullSizeCamera.SetParentOrigin(ParentOrigin::CENTER);
311
312
313     //////////////////////////////////////////////////////
314     // Connect to actor tree
315     Self().Add( mImageActorComposite );
316     Self().Add( mTargetActor );
317     Self().Add( mRenderFullSizeCamera );
318   }
319
320
321   //////////////////////////////////////////////////////
322   // Create camera for the renders corresponding to the (potentially downsampled) render targets' size
323   mRenderDownsampledCamera = CameraActor::New();
324   mRenderDownsampledCamera.SetParentOrigin(ParentOrigin::CENTER);
325
326
327   //////////////////////////////////////////////////////
328   // Connect to actor tree
329   Self().Add( mChildrenRoot );
330   Self().Add( mImageActorHorizBlur );
331   Self().Add( mImageActorVertBlur );
332   Self().Add( mRenderDownsampledCamera );
333 }
334
335
336 /**
337  * ZrelativeToYconstraint
338  *
339  * f(current, property, scale) = Vector3(current.x, current.y, property.y * scale)
340  */
341 struct ZrelativeToYconstraint
342 {
343   ZrelativeToYconstraint( float scale )
344     : mScale( scale )
345   {}
346
347   Vector3 operator()(const Vector3&    current,
348                      const PropertyInput& property)
349   {
350     Vector3 v;
351
352     v.x = current.x;
353     v.y = current.y;
354     v.z = property.GetVector3().y * mScale;
355
356     return v;
357   }
358
359   float mScale;
360 };
361
362 void GaussianBlurView::OnControlSizeSet(const Vector3& targetSize)
363 {
364   mTargetSize = Vector2(targetSize);
365
366   // if we are already on stage, need to update render target sizes now to reflect the new size of this actor
367   if(Self().OnStage())
368   {
369     AllocateResources();
370   }
371 }
372
373 void GaussianBlurView::AllocateResources()
374 {
375   // size of render targets etc is based on the size of this actor, ignoring z
376   if(mTargetSize != mLastSize)
377   {
378     mLastSize = mTargetSize;
379
380     // get size of downsampled render targets
381     mDownsampledWidth = mTargetSize.width * mDownsampleWidthScale;
382     mDownsampledHeight = mTargetSize.height * mDownsampleHeightScale;
383
384     // Create and place a camera for the renders corresponding to the (potentially downsampled) render targets' size
385     mRenderDownsampledCamera.SetFieldOfView(ARBITRARY_FIELD_OF_VIEW);
386     // 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
387     mRenderDownsampledCamera.SetNearClippingPlane(1.0f);
388     mRenderDownsampledCamera.SetAspectRatio(mDownsampledWidth / mDownsampledHeight);
389     mRenderDownsampledCamera.SetType(Dali::Camera::FREE_LOOK); // camera orientation based solely on actor
390     // Point the camera back into the scene
391     mRenderDownsampledCamera.SetRotation(Quaternion(M_PI, Vector3::YAXIS));
392
393     mRenderDownsampledCamera.SetPosition(0.0f, 0.0f, ((mDownsampledHeight * 0.5f) / tanf(ARBITRARY_FIELD_OF_VIEW * 0.5f)));
394
395     // setup for normal operation
396     if(!mBlurUserImage)
397     {
398       // Create and place a camera for the children render, corresponding to its render target size
399       mRenderFullSizeCamera.SetFieldOfView(ARBITRARY_FIELD_OF_VIEW);
400       // 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
401       mRenderFullSizeCamera.SetNearClippingPlane(1.0f);
402       mRenderFullSizeCamera.SetAspectRatio(mTargetSize.width / mTargetSize.height);
403       mRenderFullSizeCamera.SetType(Dali::Camera::FREE_LOOK); // camera orientation based solely on actor
404       // Point the camera back into the scene
405       mRenderFullSizeCamera.SetRotation(Quaternion(M_PI, Vector3::YAXIS));
406
407       float cameraPosConstraintScale = 0.5f / tanf(ARBITRARY_FIELD_OF_VIEW * 0.5f);
408       mRenderFullSizeCamera.SetPosition(0.0f, 0.0f, mTargetSize.height * cameraPosConstraintScale);
409
410       // Children render camera must move when GaussianBlurView object is resized. This is since we cannot change render target size - so we need to remap the child actors' rendering
411       // accordingly so they still exactly fill the render target. Note that this means the effective resolution of the child render changes as the GaussianBlurView object changes
412       // size, this is the trade off for not being able to modify render target size
413       // Change camera z position based on GaussianBlurView actor height
414       mRenderFullSizeCamera.RemoveConstraints();
415       mRenderFullSizeCamera.ApplyConstraint( Constraint::New<Vector3>( Actor::POSITION, ParentSource( Actor::SIZE ), ZrelativeToYconstraint(cameraPosConstraintScale) ) );
416
417       // create offscreen buffer of new size to render our child actors to
418       mRenderTargetForRenderingChildren = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Dali::Image::Unused );
419
420       // Set ImageActor for performing a horizontal blur on the texture
421       mImageActorHorizBlur.SetImage( mRenderTargetForRenderingChildren );
422
423       // Create offscreen buffer for vert blur pass
424       mRenderTarget1 = FrameBufferImage::New( mDownsampledWidth, mDownsampledHeight, mPixelFormat, Dali::Image::Unused );
425
426       // use the completed blur in the first buffer and composite with the original child actors render
427       mImageActorComposite.SetImage( mRenderTarget1 );
428
429       // set up target actor for rendering result, i.e. the blurred image
430       mTargetActor.SetImage(mRenderTargetForRenderingChildren);
431     }
432
433     // Create offscreen buffer for horiz blur pass
434     mRenderTarget2 = FrameBufferImage::New( mDownsampledWidth, mDownsampledHeight, mPixelFormat, Dali::Image::Unused );
435
436     // size needs to match render target
437     mImageActorHorizBlur.SetSize(mDownsampledWidth, mDownsampledHeight);
438
439     // size needs to match render target
440     mImageActorVertBlur.SetImage( mRenderTarget2 );
441     mImageActorVertBlur.SetSize(mDownsampledWidth, mDownsampledHeight);
442
443     // set gaussian blur up for new sized render targets
444     SetShaderConstants();
445   }
446 }
447
448 void GaussianBlurView::CreateRenderTasks()
449 {
450   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
451
452   if(!mBlurUserImage)
453   {
454     // create render task to render our child actors to offscreen buffer
455     mRenderChildrenTask = taskList.CreateTask();
456     mRenderChildrenTask.SetSourceActor( mChildrenRoot );
457     mRenderChildrenTask.SetExclusive(true);
458     mRenderChildrenTask.SetInputEnabled( false );
459     mRenderChildrenTask.SetClearEnabled( true );
460     mRenderChildrenTask.SetClearColor( mBackgroundColor );
461
462     mRenderChildrenTask.SetCameraActor(mRenderFullSizeCamera);
463     mRenderChildrenTask.SetTargetFrameBuffer( mRenderTargetForRenderingChildren );
464   }
465
466   // perform a horizontal blur targeting the second buffer
467   mHorizBlurTask = taskList.CreateTask();
468   mHorizBlurTask.SetSourceActor( mImageActorHorizBlur );
469   mHorizBlurTask.SetExclusive(true);
470   mHorizBlurTask.SetInputEnabled( false );
471   mHorizBlurTask.SetClearEnabled( true );
472   mHorizBlurTask.SetClearColor( mBackgroundColor );
473   if( mRenderOnce && mBlurUserImage )
474   {
475     mHorizBlurTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
476   }
477
478   // use the second buffer and perform a horizontal blur targeting the first buffer
479   mVertBlurTask = taskList.CreateTask();
480   mVertBlurTask.SetSourceActor( mImageActorVertBlur );
481   mVertBlurTask.SetExclusive(true);
482   mVertBlurTask.SetInputEnabled( false );
483   mVertBlurTask.SetClearEnabled( true );
484   mVertBlurTask.SetClearColor( mBackgroundColor );
485   if( mRenderOnce && mBlurUserImage )
486   {
487     mVertBlurTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
488     mVertBlurTask.FinishedSignal().Connect( this, &GaussianBlurView::OnRenderTaskFinished );
489   }
490
491   // use the completed blur in the first buffer and composite with the original child actors render
492   if(!mBlurUserImage)
493   {
494     mCompositeTask = taskList.CreateTask();
495     mCompositeTask.SetSourceActor( mImageActorComposite );
496     mCompositeTask.SetExclusive(true);
497     mCompositeTask.SetInputEnabled( false );
498
499     mCompositeTask.SetCameraActor(mRenderFullSizeCamera);
500     mCompositeTask.SetTargetFrameBuffer( mRenderTargetForRenderingChildren );
501   }
502
503   mHorizBlurTask.SetCameraActor(mRenderDownsampledCamera);
504   mVertBlurTask.SetCameraActor(mRenderDownsampledCamera);
505
506   mHorizBlurTask.SetTargetFrameBuffer( mRenderTarget2 );
507   if(mUserOutputRenderTarget)
508   {
509     mVertBlurTask.SetTargetFrameBuffer( mUserOutputRenderTarget );
510   }
511   else
512   {
513     mVertBlurTask.SetTargetFrameBuffer( mRenderTarget1 );
514   }
515 }
516
517 void GaussianBlurView::RemoveRenderTasks()
518 {
519   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
520
521   taskList.RemoveTask(mRenderChildrenTask);
522   taskList.RemoveTask(mHorizBlurTask);
523   taskList.RemoveTask(mVertBlurTask);
524   taskList.RemoveTask(mCompositeTask);
525 }
526
527 void GaussianBlurView::OnStageDisconnection()
528 {
529   // TODO: can't call this here, since SetImage() calls fails similarly to above
530   // Need to fix the stage connection so this callback can be used arbitrarily. At that point we  can simplify the API by removing the need for Activate() / Deactivate()
531   //Deactivate();
532 }
533
534 void GaussianBlurView::OnControlStageConnection()
535 {
536   // TODO: can't call this here, since SetImage() calls fail to connect images to stage, since parent chain not fully on stage yet
537   // Need to fix the stage connection so this callback can be used arbitrarily. At that point we  can simplify the API by removing the need for Activate() / Deactivate()
538   //Activate();
539 }
540
541 void GaussianBlurView::Activate()
542 {
543   // make sure resources are allocated and start the render tasks processing
544   AllocateResources();
545   CreateRenderTasks();
546 }
547
548 void GaussianBlurView::ActivateOnce()
549 {
550   DALI_ASSERT_ALWAYS(mBlurUserImage); // Only works with blurring image mode.
551   mRenderOnce = true;
552   Activate();
553 }
554
555 void GaussianBlurView::Deactivate()
556 {
557   // stop render tasks processing
558   // Note: render target resources are automatically freed since we set the Image::Unused flag
559   RemoveRenderTasks();
560   mRenderOnce = false;
561 }
562
563 void GaussianBlurView::SetBlurBellCurveWidth(float blurBellCurveWidth)
564 {
565   // a value of zero leads to undefined Gaussian weights, do not allow user to do this
566   mBlurBellCurveWidth = std::max( blurBellCurveWidth, 0.001f );
567 }
568
569 float GaussianBlurView::CalcGaussianWeight(float x)
570 {
571   return (1.0f / sqrt(2.0f * Math::PI * mBlurBellCurveWidth)) * exp(-(x * x) / (2.0f * mBlurBellCurveWidth * mBlurBellCurveWidth));
572 }
573
574 void GaussianBlurView::SetShaderConstants()
575 {
576   Vector2 *uvOffsets;
577   float ofs;
578   float *weights;
579   float w, totalWeights;
580   unsigned int i;
581
582   uvOffsets = new Vector2[mNumSamples + 1];
583   weights = new float[mNumSamples + 1];
584
585   totalWeights = weights[0] = CalcGaussianWeight(0);
586   uvOffsets[0].x = 0.0f;
587   uvOffsets[0].y = 0.0f;
588
589   for(i=0; i<mNumSamples >> 1; i++)
590   {
591     w = CalcGaussianWeight((float)(i + 1));
592     weights[(i << 1) + 1] = w;
593     weights[(i << 1) + 2] = w;
594     totalWeights += w * 2.0f;
595
596     // offset texture lookup to between texels, that way the bilinear filter in the texture hardware will average two samples with one lookup
597     ofs = ((float)(i << 1)) + 1.5f;
598
599     // get offsets from units of pixels into uv coordinates in [0..1]
600     float ofsX = ofs / mDownsampledWidth;
601     float ofsY = ofs / mDownsampledHeight;
602     uvOffsets[(i << 1) + 1].x = ofsX;
603     uvOffsets[(i << 1) + 1].y = ofsY;
604
605     uvOffsets[(i << 1) + 2].x = -ofsX;
606     uvOffsets[(i << 1) + 2].y = -ofsY;
607   }
608
609   for(i=0; i<mNumSamples; i++)
610   {
611     weights[i] /= totalWeights;
612   }
613
614   // set shader constants
615   Vector2 xAxis(1.0f, 0.0f);
616   Vector2 yAxis(0.0f, 1.0f);
617   for (i = 0; i < mNumSamples; ++i )
618   {
619     mHorizBlurShader.SetUniform( GetSampleOffsetsPropertyName( i ), uvOffsets[ i ] * xAxis );
620     mHorizBlurShader.SetUniform( GetSampleWeightsPropertyName( i ), weights[ i ] );
621
622     mVertBlurShader.SetUniform( GetSampleOffsetsPropertyName( i ), uvOffsets[ i ] * yAxis );
623     mVertBlurShader.SetUniform( GetSampleWeightsPropertyName( i ), weights[ i ] );
624   }
625
626   delete[] uvOffsets;
627   delete[] weights;
628 }
629
630 std::string GaussianBlurView::GetSampleOffsetsPropertyName( unsigned int index ) const
631 {
632   DALI_ASSERT_ALWAYS( index < mNumSamples );
633
634   std::ostringstream oss;
635   oss << "uSampleOffsets[" << index << "]";
636   return oss.str();
637 }
638
639 std::string GaussianBlurView::GetSampleWeightsPropertyName( unsigned int index ) const
640 {
641   DALI_ASSERT_ALWAYS( index < mNumSamples );
642
643   std::ostringstream oss;
644   oss << "uSampleWeights[" << index << "]";
645   return oss.str();
646 }
647
648 Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal& GaussianBlurView::FinishedSignal()
649 {
650   return mFinishedSignal;
651 }
652
653 void GaussianBlurView::OnRenderTaskFinished(Dali::RenderTask& renderTask)
654 {
655   Toolkit::GaussianBlurView handle( GetOwner() );
656   mFinishedSignal.Emit( handle );
657 }
658
659 } // namespace Internal
660 } // namespace Toolkit
661 } // namespace Dali