X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fcontrols%2Fgaussian-blur-view%2Fgaussian-blur-view-impl.cpp;h=7fd6fdf9d04a579eb785c2b812ae861038fd2368;hp=95984f5cd231f461820d1a559e3ecf0cd5f20b34;hb=8a647e87a01c5c78451653c1264a9eea81ac9b20;hpb=a3ab994876ea86236784101dd85370815c336e8b diff --git a/dali-toolkit/internal/controls/gaussian-blur-view/gaussian-blur-view-impl.cpp b/dali-toolkit/internal/controls/gaussian-blur-view/gaussian-blur-view-impl.cpp index 95984f5..7fd6fdf 100644 --- a/dali-toolkit/internal/controls/gaussian-blur-view/gaussian-blur-view-impl.cpp +++ b/dali-toolkit/internal/controls/gaussian-blur-view/gaussian-blur-view-impl.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016 Samsung Electronics Co., Ltd. + * Copyright (c) 2020 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -23,14 +23,20 @@ #include #include #include -#include +#include #include #include +#include +#include +#include #include #include +#include // INTERNAL INCLUDES #include +#include +#include // TODO: // pixel format / size - set from JSON @@ -54,13 +60,13 @@ // 2 modes: // 1st mode, this control has a tree of actors (use Add() to add children) that are rendered and blurred. // mRenderChildrenTask renders children to FB mRenderTargetForRenderingChildren -// mHorizBlurTask renders mImageViewHorizBlur Actor showing FB mRenderTargetForRenderingChildren into FB mRenderTarget2 -// mVertBlurTask renders mImageViewVertBlur Actor showing FB mRenderTarget2 into FB mRenderTarget1 -// mCompositeTask renders mImageViewComposite Actor showing FB mRenderTarget1 into FB mRenderTargetForRenderingChildren +// mHorizBlurTask renders mHorizBlurActor Actor showing FB mRenderTargetForRenderingChildren into FB mRenderTarget2 +// mVertBlurTask renders mVertBlurActor Actor showing FB mRenderTarget2 into FB mRenderTarget1 +// mCompositeTask renders mCompositingActor Actor showing FB mRenderTarget1 into FB mRenderTargetForRenderingChildren // // 2nd mode, an image is blurred and rendered to a supplied target framebuffer -// mHorizBlurTask renders mImageViewHorizBlur Actor showing mUserInputImage into FB mRenderTarget2 -// mVertBlurTask renders mImageViewVertBlur Actor showing mRenderTarget2 into FB mUserOutputRenderTarget +// mHorizBlurTask renders mHorizBlurActor Actor showing mUserInputImage into FB mRenderTarget2 +// mVertBlurTask renders mVertBlurActor Actor showing mRenderTarget2 into FB mUserOutputRenderTarget // // Only this 2nd mode handles ActivateOnce @@ -96,22 +102,23 @@ const float GAUSSIAN_BLUR_VIEW_DEFAULT_DOWNSAMPLE_HEIGHT_SCALE = 0.5f; const float ARBITRARY_FIELD_OF_VIEW = Math::PI / 4.0f; -const char* const GAUSSIAN_BLUR_FRAGMENT_SOURCE = - "varying mediump vec2 vTexCoord;\n" - "uniform sampler2D sTexture;\n" - "uniform lowp vec4 uColor;\n" - "uniform mediump vec2 uSampleOffsets[NUM_SAMPLES];\n" - "uniform mediump float uSampleWeights[NUM_SAMPLES];\n" - - "void main()\n" - "{\n" - " mediump vec4 col = texture2D(sTexture, vTexCoord + uSampleOffsets[0]) * uSampleWeights[0];\n" - " for (int i=1; i( + new Control::Impl::AccessibleImpl( actor, Dali::Accessibility::Role::FILLER ) ); + } ); } GaussianBlurView::GaussianBlurView( const unsigned int numSamples, @@ -200,32 +211,19 @@ Toolkit::GaussianBlurView GaussianBlurView::New(const unsigned int numSamples, c return handle; } -///////////////////////////////////////////////////////////// -// 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 -// DEPRECATED: overloading Actor::Add()/Remove() not nice since breaks polymorphism. Need another method to pass ownership of added child actors to our internal actor root. -void GaussianBlurView::Add(Actor child) -{ - mChildrenRoot.Add(child); -} - -void GaussianBlurView::Remove(Actor child) -{ - mChildrenRoot.Remove(child); -} - -void GaussianBlurView::SetUserImageAndOutputRenderTarget(Image inputImage, FrameBufferImage outputRenderTarget) +void GaussianBlurView::SetUserImageAndOutputRenderTarget(Texture inputImage, FrameBuffer outputRenderTarget) { // can only do this if the GaussianBlurView object was created with this parameter set DALI_ASSERT_ALWAYS(mBlurUserImage); mUserInputImage = inputImage; - mImageViewHorizBlur.SetImage( mUserInputImage ); - mImageViewHorizBlur.SetProperty( Toolkit::ImageView::Property::IMAGE, mCustomShader ); + + SetRendererTexture( mHorizBlurActor.GetRendererAt(0), inputImage ); mUserOutputRenderTarget = outputRenderTarget; } -FrameBufferImage GaussianBlurView::GetBlurredRenderTarget() const +FrameBuffer GaussianBlurView::GetBlurredRenderTarget() const { if(!mUserOutputRenderTarget) { @@ -253,29 +251,31 @@ Vector4 GaussianBlurView::GetBackgroundColor() const void GaussianBlurView::OnInitialize() { // root actor to parent all user added actors, needed to allow us to set that subtree as exclusive for our child render task - mChildrenRoot.SetParentOrigin(ParentOrigin::CENTER); - mInternalRoot.SetParentOrigin(ParentOrigin::CENTER); + mChildrenRoot.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER ); + mInternalRoot.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER ); ////////////////////////////////////////////////////// // Create shaders - std::ostringstream horizFragmentShaderStringStream; - horizFragmentShaderStringStream << "#define NUM_SAMPLES " << mNumSamples << "\n"; - horizFragmentShaderStringStream << GAUSSIAN_BLUR_FRAGMENT_SOURCE; - Property::Map source; - source[ Toolkit::Visual::Shader::Property::FRAGMENT_SHADER ] = horizFragmentShaderStringStream.str(); - mCustomShader[ Toolkit::Visual::Property::SHADER ] = source; + std::ostringstream fragmentStringStream; + fragmentStringStream << "#define NUM_SAMPLES " << mNumSamples << "\n"; + fragmentStringStream << GAUSSIAN_BLUR_FRAGMENT_SOURCE; + std::string fragmentSource(fragmentStringStream.str()); ////////////////////////////////////////////////////// // Create actors - // Create an image view for performing a horizontal blur on the texture - mImageViewHorizBlur = Toolkit::ImageView::New(); - mImageViewHorizBlur.SetParentOrigin(ParentOrigin::CENTER); + // Create an actor for performing a horizontal blur on the texture + mHorizBlurActor = Actor::New(); + mHorizBlurActor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER ); + Renderer renderer = CreateRenderer( BASIC_VERTEX_SOURCE, fragmentSource.c_str() ); + mHorizBlurActor.AddRenderer( renderer ); - // Create an image view for performing a vertical blur on the texture - mImageViewVertBlur = Toolkit::ImageView::New(); - mImageViewVertBlur.SetParentOrigin(ParentOrigin::CENTER); + // Create an actor for performing a vertical blur on the texture + mVertBlurActor = Actor::New(); + mVertBlurActor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER ); + renderer = CreateRenderer( BASIC_VERTEX_SOURCE, fragmentSource.c_str() ); + mVertBlurActor.AddRenderer( renderer ); // Register a property that the user can control to fade the blur in / out via the GaussianBlurView object Actor self = Self(); @@ -284,69 +284,67 @@ void GaussianBlurView::OnInitialize() // Create an image view for compositing the blur and the original child actors render if(!mBlurUserImage) { - mImageViewComposite = Toolkit::ImageView::New(); - mImageViewComposite.SetParentOrigin(ParentOrigin::CENTER); - mImageViewComposite.SetOpacity(GAUSSIAN_BLUR_VIEW_DEFAULT_BLUR_STRENGTH); // ensure alpha is enabled for this object and set default value + mCompositingActor = Actor::New(); + mCompositingActor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER ); + mCompositingActor.SetProperty( Actor::Property::OPACITY,GAUSSIAN_BLUR_VIEW_DEFAULT_BLUR_STRENGTH); // ensure alpha is enabled for this object and set default value + renderer = CreateRenderer( BASIC_VERTEX_SOURCE, BASIC_FRAGMENT_SOURCE ); + mCompositingActor.AddRenderer( renderer ); - Constraint blurStrengthConstraint = Constraint::New( mImageViewComposite, Actor::Property::COLOR_ALPHA, EqualToConstraint()); + Constraint blurStrengthConstraint = Constraint::New( mCompositingActor, Actor::Property::COLOR_ALPHA, EqualToConstraint()); blurStrengthConstraint.AddSource( Source( self, mBlurStrengthPropertyIndex) ); blurStrengthConstraint.Apply(); // Create an image view for holding final result, i.e. the blurred image. This will get rendered to screen later, via default / user render task - mTargetActor = Toolkit::ImageView::New(); - mTargetActor.SetParentOrigin(ParentOrigin::CENTER); + mTargetActor = Actor::New(); + mTargetActor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER ); + renderer = CreateRenderer( BASIC_VERTEX_SOURCE, BASIC_FRAGMENT_SOURCE ); + mTargetActor.AddRenderer( renderer ); ////////////////////////////////////////////////////// // Create cameras for the renders corresponding to the view size mRenderFullSizeCamera = CameraActor::New(); mRenderFullSizeCamera.SetInvertYAxis( true ); - mRenderFullSizeCamera.SetParentOrigin(ParentOrigin::CENTER); - + mRenderFullSizeCamera.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER ); ////////////////////////////////////////////////////// // Connect to actor tree - mInternalRoot.Add( mImageViewComposite ); + mInternalRoot.Add( mCompositingActor ); mInternalRoot.Add( mTargetActor ); mInternalRoot.Add( mRenderFullSizeCamera ); } - ////////////////////////////////////////////////////// // Create camera for the renders corresponding to the (potentially downsampled) render targets' size mRenderDownsampledCamera = CameraActor::New(); mRenderDownsampledCamera.SetInvertYAxis( true ); - mRenderDownsampledCamera.SetParentOrigin(ParentOrigin::CENTER); - + mRenderDownsampledCamera.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER ); ////////////////////////////////////////////////////// // Connect to actor tree Self().Add( mChildrenRoot ); - Self().Add( mInternalRoot ); - mInternalRoot.Add( mImageViewHorizBlur ); - mInternalRoot.Add( mImageViewVertBlur ); + mInternalRoot.Add( mHorizBlurActor ); + mInternalRoot.Add( mVertBlurActor ); mInternalRoot.Add( mRenderDownsampledCamera ); } void GaussianBlurView::OnSizeSet(const Vector3& targetSize) { - Control::OnSizeSet( targetSize ); - mTargetSize = Vector2(targetSize); - mChildrenRoot.SetSize(targetSize); + mChildrenRoot.SetProperty( Actor::Property::SIZE, targetSize); if( !mBlurUserImage ) { - mImageViewComposite.SetSize(targetSize); - mTargetActor.SetSize(targetSize); + mCompositingActor.SetProperty( Actor::Property::SIZE, targetSize); + mTargetActor.SetProperty( Actor::Property::SIZE, targetSize); // 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 // 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 // size, this is the trade off for not being able to modify render target size // Change camera z position based on GaussianBlurView actor height float cameraPosConstraintScale = 0.5f / tanf(ARBITRARY_FIELD_OF_VIEW * 0.5f); - mRenderFullSizeCamera.SetZ(mTargetSize.height * cameraPosConstraintScale); + mRenderFullSizeCamera.SetProperty( Actor::Property::POSITION_Z, mTargetSize.height * cameraPosConstraintScale); } @@ -356,16 +354,18 @@ void GaussianBlurView::OnSizeSet(const Vector3& targetSize) Deactivate(); Activate(); } + + Control::OnSizeSet( targetSize ); } void GaussianBlurView::OnChildAdd( Actor& child ) { - Control::OnChildAdd( child ); - if( child != mChildrenRoot && child != mInternalRoot) { mChildrenRoot.Add( child ); } + + Control::OnChildAdd( child ); } void GaussianBlurView::OnChildRemove( Actor& child ) @@ -377,68 +377,68 @@ void GaussianBlurView::OnChildRemove( Actor& child ) void GaussianBlurView::AllocateResources() { - // size of render targets etc is based on the size of this actor, ignoring z - if(mTargetSize != mLastSize) - { - mLastSize = mTargetSize; + mLastSize = mTargetSize; - // get size of downsampled render targets - mDownsampledWidth = mTargetSize.width * mDownsampleWidthScale; - mDownsampledHeight = mTargetSize.height * mDownsampleHeightScale; + // get size of downsampled render targets + mDownsampledWidth = mTargetSize.width * mDownsampleWidthScale; + mDownsampledHeight = mTargetSize.height * mDownsampleHeightScale; - // Create and place a camera for the renders corresponding to the (potentially downsampled) render targets' size - mRenderDownsampledCamera.SetFieldOfView(ARBITRARY_FIELD_OF_VIEW); - // 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 - mRenderDownsampledCamera.SetNearClippingPlane(1.0f); - mRenderDownsampledCamera.SetAspectRatio(mDownsampledWidth / mDownsampledHeight); - mRenderDownsampledCamera.SetType(Dali::Camera::FREE_LOOK); // camera orientation based solely on actor + // Create and place a camera for the renders corresponding to the (potentially downsampled) render targets' size + mRenderDownsampledCamera.SetFieldOfView(ARBITRARY_FIELD_OF_VIEW); + // 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 + mRenderDownsampledCamera.SetNearClippingPlane(1.0f); + mRenderDownsampledCamera.SetAspectRatio(mDownsampledWidth / mDownsampledHeight); + mRenderDownsampledCamera.SetType(Dali::Camera::FREE_LOOK); // camera orientation based solely on actor - mRenderDownsampledCamera.SetPosition(0.0f, 0.0f, ((mDownsampledHeight * 0.5f) / tanf(ARBITRARY_FIELD_OF_VIEW * 0.5f))); + mRenderDownsampledCamera.SetProperty( Actor::Property::POSITION, Vector3(0.0f, 0.0f, ((mDownsampledHeight * 0.5f) / tanf(ARBITRARY_FIELD_OF_VIEW * 0.5f)))); - // setup for normal operation - if(!mBlurUserImage) - { - // Create and place a camera for the children render, corresponding to its render target size - mRenderFullSizeCamera.SetFieldOfView(ARBITRARY_FIELD_OF_VIEW); - // 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 - mRenderFullSizeCamera.SetNearClippingPlane(1.0f); - mRenderFullSizeCamera.SetAspectRatio(mTargetSize.width / mTargetSize.height); - mRenderFullSizeCamera.SetType(Dali::Camera::FREE_LOOK); // camera orientation based solely on actor + // setup for normal operation + if(!mBlurUserImage) + { + // Create and place a camera for the children render, corresponding to its render target size + mRenderFullSizeCamera.SetFieldOfView(ARBITRARY_FIELD_OF_VIEW); + // 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 + mRenderFullSizeCamera.SetNearClippingPlane(1.0f); + mRenderFullSizeCamera.SetAspectRatio(mTargetSize.width / mTargetSize.height); + mRenderFullSizeCamera.SetType(Dali::Camera::FREE_LOOK); // camera orientation based solely on actor - float cameraPosConstraintScale = 0.5f / tanf(ARBITRARY_FIELD_OF_VIEW * 0.5f); - mRenderFullSizeCamera.SetPosition(0.0f, 0.0f, mTargetSize.height * cameraPosConstraintScale); + float cameraPosConstraintScale = 0.5f / tanf(ARBITRARY_FIELD_OF_VIEW * 0.5f); + mRenderFullSizeCamera.SetProperty( Actor::Property::POSITION, Vector3(0.0f, 0.0f, mTargetSize.height * cameraPosConstraintScale)); - // create offscreen buffer of new size to render our child actors to - mRenderTargetForRenderingChildren = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat ); + // create offscreen buffer of new size to render our child actors to + mRenderTargetForRenderingChildren = FrameBuffer::New( mTargetSize.width, mTargetSize.height, FrameBuffer::Attachment::NONE ); + Texture texture = Texture::New( TextureType::TEXTURE_2D, mPixelFormat, unsigned(mTargetSize.width), unsigned(mTargetSize.height) ); + mRenderTargetForRenderingChildren.AttachColorTexture( texture ); - // Set image view for performing a horizontal blur on the texture - mImageViewHorizBlur.SetImage( mRenderTargetForRenderingChildren ); - mImageViewHorizBlur.SetProperty( Toolkit::ImageView::Property::IMAGE, mCustomShader ); + // Set actor for performing a horizontal blur + SetRendererTexture( mHorizBlurActor.GetRendererAt(0), mRenderTargetForRenderingChildren ); - // Create offscreen buffer for vert blur pass - mRenderTarget1 = FrameBufferImage::New( mDownsampledWidth, mDownsampledHeight, mPixelFormat ); + // Create offscreen buffer for vert blur pass + mRenderTarget1 = FrameBuffer::New( mDownsampledWidth, mDownsampledHeight, FrameBuffer::Attachment::NONE ); + texture = Texture::New(TextureType::TEXTURE_2D, mPixelFormat, unsigned(mDownsampledWidth), unsigned(mDownsampledHeight)); + mRenderTarget1.AttachColorTexture( texture ); - // use the completed blur in the first buffer and composite with the original child actors render - mImageViewComposite.SetImage( mRenderTarget1 ); + // use the completed blur in the first buffer and composite with the original child actors render + SetRendererTexture( mCompositingActor.GetRendererAt(0), mRenderTarget1 ); - // set up target actor for rendering result, i.e. the blurred image - mTargetActor.SetImage(mRenderTargetForRenderingChildren); - } + // set up target actor for rendering result, i.e. the blurred image + SetRendererTexture( mTargetActor.GetRendererAt(0), mRenderTargetForRenderingChildren ); + } - // Create offscreen buffer for horiz blur pass - mRenderTarget2 = FrameBufferImage::New( mDownsampledWidth, mDownsampledHeight, mPixelFormat ); + // Create offscreen buffer for horiz blur pass + mRenderTarget2 = FrameBuffer::New( mDownsampledWidth, mDownsampledHeight, FrameBuffer::Attachment::NONE ); + Texture texture = Texture::New(TextureType::TEXTURE_2D, mPixelFormat, unsigned(mDownsampledWidth), unsigned(mDownsampledHeight)); + mRenderTarget2.AttachColorTexture( texture ); - // size needs to match render target - mImageViewHorizBlur.SetSize(mDownsampledWidth, mDownsampledHeight); + // size needs to match render target + mHorizBlurActor.SetProperty( Actor::Property::SIZE, Vector2(mDownsampledWidth, mDownsampledHeight) ); - // size needs to match render target - mImageViewVertBlur.SetImage( mRenderTarget2 ); - mImageViewVertBlur.SetProperty( Toolkit::ImageView::Property::IMAGE, mCustomShader ); - mImageViewVertBlur.SetSize(mDownsampledWidth, mDownsampledHeight); + // size needs to match render target + mVertBlurActor.SetProperty( Actor::Property::SIZE, Vector2(mDownsampledWidth, mDownsampledHeight) ); + SetRendererTexture( mVertBlurActor.GetRendererAt(0), mRenderTarget2 ); - // set gaussian blur up for new sized render targets - SetShaderConstants(); - } + // set gaussian blur up for new sized render targets + SetShaderConstants(); } void GaussianBlurView::CreateRenderTasks() @@ -456,26 +456,31 @@ void GaussianBlurView::CreateRenderTasks() mRenderChildrenTask.SetClearColor( mBackgroundColor ); mRenderChildrenTask.SetCameraActor(mRenderFullSizeCamera); - mRenderChildrenTask.SetTargetFrameBuffer( mRenderTargetForRenderingChildren ); + mRenderChildrenTask.SetFrameBuffer( mRenderTargetForRenderingChildren ); + + if( mRenderOnce ) + { + mRenderChildrenTask.SetRefreshRate(RenderTask::REFRESH_ONCE); + } } // perform a horizontal blur targeting the second buffer mHorizBlurTask = taskList.CreateTask(); - mHorizBlurTask.SetSourceActor( mImageViewHorizBlur ); + mHorizBlurTask.SetSourceActor( mHorizBlurActor ); mHorizBlurTask.SetExclusive(true); mHorizBlurTask.SetInputEnabled( false ); mHorizBlurTask.SetClearEnabled( true ); mHorizBlurTask.SetClearColor( mBackgroundColor ); mHorizBlurTask.SetCameraActor(mRenderDownsampledCamera); - mHorizBlurTask.SetTargetFrameBuffer( mRenderTarget2 ); - if( mRenderOnce && mBlurUserImage ) + mHorizBlurTask.SetFrameBuffer( mRenderTarget2 ); + if( mRenderOnce || ( mRenderOnce && mBlurUserImage ) ) { mHorizBlurTask.SetRefreshRate(RenderTask::REFRESH_ONCE); } // use the second buffer and perform a horizontal blur targeting the first buffer mVertBlurTask = taskList.CreateTask(); - mVertBlurTask.SetSourceActor( mImageViewVertBlur ); + mVertBlurTask.SetSourceActor( mVertBlurActor ); mVertBlurTask.SetExclusive(true); mVertBlurTask.SetInputEnabled( false ); mVertBlurTask.SetClearEnabled( true ); @@ -483,13 +488,13 @@ void GaussianBlurView::CreateRenderTasks() mVertBlurTask.SetCameraActor(mRenderDownsampledCamera); if(mUserOutputRenderTarget) { - mVertBlurTask.SetTargetFrameBuffer( mUserOutputRenderTarget ); + mVertBlurTask.SetFrameBuffer( mUserOutputRenderTarget ); } else { - mVertBlurTask.SetTargetFrameBuffer( mRenderTarget1 ); + mVertBlurTask.SetFrameBuffer( mRenderTarget1 ); } - if( mRenderOnce && mBlurUserImage ) + if( mRenderOnce || ( mRenderOnce && mBlurUserImage ) ) { mVertBlurTask.SetRefreshRate(RenderTask::REFRESH_ONCE); mVertBlurTask.FinishedSignal().Connect( this, &GaussianBlurView::OnRenderTaskFinished ); @@ -499,12 +504,17 @@ void GaussianBlurView::CreateRenderTasks() if(!mBlurUserImage) { mCompositeTask = taskList.CreateTask(); - mCompositeTask.SetSourceActor( mImageViewComposite ); + mCompositeTask.SetSourceActor( mCompositingActor ); mCompositeTask.SetExclusive(true); mCompositeTask.SetInputEnabled( false ); mCompositeTask.SetCameraActor(mRenderFullSizeCamera); - mCompositeTask.SetTargetFrameBuffer( mRenderTargetForRenderingChildren ); + mCompositeTask.SetFrameBuffer( mRenderTargetForRenderingChildren ); + + if( mRenderOnce ) + { + mCompositeTask.SetRefreshRate(RenderTask::REFRESH_ONCE); + } } } @@ -520,29 +530,37 @@ void GaussianBlurView::RemoveRenderTasks() void GaussianBlurView::Activate() { - // make sure resources are allocated and start the render tasks processing - AllocateResources(); - CreateRenderTasks(); - mActivated = true; + if( !mActivated ) + { + // make sure resources are allocated and start the render tasks processing + Self().Add( mInternalRoot ); + AllocateResources(); + CreateRenderTasks(); + mActivated = true; + } } void GaussianBlurView::ActivateOnce() { - DALI_ASSERT_ALWAYS(mBlurUserImage); // Only works with blurring image mode. + Deactivate(); mRenderOnce = true; Activate(); } void GaussianBlurView::Deactivate() { - // stop render tasks processing - // Note: render target resources are automatically freed since we set the Image::Unused flag - RemoveRenderTasks(); - mRenderTargetForRenderingChildren.Reset(); - mRenderTarget1.Reset(); - mRenderTarget2.Reset(); - mRenderOnce = false; - mActivated = false; + if( mActivated ) + { + // stop render tasks processing + // Note: render target resources are automatically freed since we set the Image::Unused flag + mInternalRoot.Unparent(); + mRenderTargetForRenderingChildren.Reset(); + mRenderTarget1.Reset(); + mRenderTarget2.Reset(); + RemoveRenderTasks(); + mRenderOnce = false; + mActivated = false; + } } void GaussianBlurView::SetBlurBellCurveWidth(float blurBellCurveWidth) @@ -601,11 +619,11 @@ void GaussianBlurView::SetShaderConstants() Vector2 yAxis(0.0f, 1.0f); for (i = 0; i < mNumSamples; ++i ) { - mImageViewHorizBlur.RegisterProperty( GetSampleOffsetsPropertyName( i ), uvOffsets[ i ] * xAxis ); - mImageViewHorizBlur.RegisterProperty( GetSampleWeightsPropertyName( i ), weights[ i ] ); + mHorizBlurActor.RegisterProperty( GetSampleOffsetsPropertyName( i ), uvOffsets[ i ] * xAxis ); + mHorizBlurActor.RegisterProperty( GetSampleWeightsPropertyName( i ), weights[ i ] ); - mImageViewVertBlur.RegisterProperty( GetSampleOffsetsPropertyName( i ), uvOffsets[ i ] * yAxis ); - mImageViewVertBlur.RegisterProperty( GetSampleWeightsPropertyName( i ), weights[ i ] ); + mVertBlurActor.RegisterProperty( GetSampleOffsetsPropertyName( i ), uvOffsets[ i ] * yAxis ); + mVertBlurActor.RegisterProperty( GetSampleWeightsPropertyName( i ), weights[ i ] ); } delete[] uvOffsets;