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=a471455df50b1322375b840c489234c2a977952d;hp=95984f5cd231f461820d1a559e3ecf0cd5f20b34;hb=0512ac82e2c23d8eada7840b5a72cdabe13a5f54;hpb=84e05cec3039abe8ecaaa950d4f93dd4f94282fe 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..a471455 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) 2021 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. @@ -19,17 +19,25 @@ #include "gaussian-blur-view-impl.h" // EXTERNAL INCLUDES -#include -#include +#include +#include +#include #include #include -#include -#include #include +#include #include -#include +#include +#include +#include +#include +#include // INTERNAL INCLUDES +#include +#include +#include +#include #include // TODO: @@ -38,7 +46,6 @@ // default near clip value // Manager object - re-use render targets if there are multiple GaussianBlurViews created - ///////////////////////////////////////////////////////// // IMPLEMENTATION NOTES @@ -50,32 +57,27 @@ // 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 // by using constraints relative to the GaussianBlurView actor size. - // 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 namespace Dali { - namespace Toolkit { - namespace Internal { - namespace { - using namespace Dali; BaseHandle Create() @@ -83,84 +85,66 @@ BaseHandle Create() return Toolkit::GaussianBlurView::New(); } -DALI_TYPE_REGISTRATION_BEGIN( Toolkit::GaussianBlurView, Toolkit::Control, Create ) +DALI_TYPE_REGISTRATION_BEGIN(Toolkit::GaussianBlurView, Toolkit::Control, Create) DALI_TYPE_REGISTRATION_END() -const unsigned int GAUSSIAN_BLUR_VIEW_DEFAULT_NUM_SAMPLES = 5; -const float GAUSSIAN_BLUR_VIEW_DEFAULT_BLUR_BELL_CURVE_WIDTH = 1.5f; +const unsigned int GAUSSIAN_BLUR_VIEW_DEFAULT_NUM_SAMPLES = 5; +const float GAUSSIAN_BLUR_VIEW_DEFAULT_BLUR_BELL_CURVE_WIDTH = 1.5f; const Pixel::Format GAUSSIAN_BLUR_VIEW_DEFAULT_RENDER_TARGET_PIXEL_FORMAT = Pixel::RGBA8888; -const float GAUSSIAN_BLUR_VIEW_DEFAULT_BLUR_STRENGTH = 1.0f; // default, fully blurred -const char* const GAUSSIAN_BLUR_VIEW_STRENGTH_PROPERTY_NAME = "GaussianBlurStrengthPropertyName"; -const float GAUSSIAN_BLUR_VIEW_DEFAULT_DOWNSAMPLE_WIDTH_SCALE = 0.5f; -const float GAUSSIAN_BLUR_VIEW_DEFAULT_DOWNSAMPLE_HEIGHT_SCALE = 0.5f; +const float GAUSSIAN_BLUR_VIEW_DEFAULT_BLUR_STRENGTH = 1.0f; // default, fully blurred +const char* const GAUSSIAN_BLUR_VIEW_STRENGTH_PROPERTY_NAME = "GaussianBlurStrengthPropertyName"; +const float GAUSSIAN_BLUR_VIEW_DEFAULT_DOWNSAMPLE_WIDTH_SCALE = 0.5f; +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( mImageViewComposite, Actor::Property::COLOR_ALPHA, EqualToConstraint()); - blurStrengthConstraint.AddSource( Source( self, mBlurStrengthPropertyIndex) ); + 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(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.SetInvertYAxis(true); + mRenderFullSizeCamera.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER); ////////////////////////////////////////////////////// // Connect to actor tree - mInternalRoot.Add( mImageViewComposite ); - mInternalRoot.Add( mTargetActor ); - mInternalRoot.Add( mRenderFullSizeCamera ); + 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.SetInvertYAxis(true); + 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( mRenderDownsampledCamera ); + Self().Add(mChildrenRoot); + mInternalRoot.Add(mHorizBlurActor); + mInternalRoot.Add(mVertBlurActor); + mInternalRoot.Add(mRenderDownsampledCamera); + + DevelControl::SetAccessibilityConstructor(Self(), [](Dali::Actor actor) { + return std::make_unique(actor, Dali::Accessibility::Role::FILLER); + }); } - void GaussianBlurView::OnSizeSet(const Vector3& targetSize) { - Control::OnSizeSet( targetSize ); - mTargetSize = Vector2(targetSize); - mChildrenRoot.SetSize(targetSize); + mChildrenRoot.SetProperty(Actor::Property::SIZE, targetSize); - if( !mBlurUserImage ) + 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); } - // if we have already activated the blur, need to update render target sizes now to reflect the new size of this actor if(mActivated) { Deactivate(); Activate(); } + + Control::OnSizeSet(targetSize); } -void GaussianBlurView::OnChildAdd( Actor& child ) +void GaussianBlurView::OnChildAdd(Actor& child) { - Control::OnChildAdd( child ); - - if( child != mChildrenRoot && child != mInternalRoot) + if(child != mChildrenRoot && child != mInternalRoot) { - mChildrenRoot.Add( child ); + mChildrenRoot.Add(child); } + + Control::OnChildAdd(child); } -void GaussianBlurView::OnChildRemove( Actor& child ) +void GaussianBlurView::OnChildRemove(Actor& child) { - mChildrenRoot.Remove( child ); + mChildrenRoot.Remove(child); - Control::OnChildRemove( child ); + Control::OnChildRemove(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() @@ -449,62 +420,72 @@ void GaussianBlurView::CreateRenderTasks() { // create render task to render our child actors to offscreen buffer mRenderChildrenTask = taskList.CreateTask(); - mRenderChildrenTask.SetSourceActor( mChildrenRoot ); + mRenderChildrenTask.SetSourceActor(mChildrenRoot); mRenderChildrenTask.SetExclusive(true); - mRenderChildrenTask.SetInputEnabled( false ); - mRenderChildrenTask.SetClearEnabled( true ); - mRenderChildrenTask.SetClearColor( mBackgroundColor ); + mRenderChildrenTask.SetInputEnabled(false); + mRenderChildrenTask.SetClearEnabled(true); + 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.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 ); - mVertBlurTask.SetClearColor( mBackgroundColor ); + mVertBlurTask.SetInputEnabled(false); + mVertBlurTask.SetClearEnabled(true); + mVertBlurTask.SetClearColor(mBackgroundColor); 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 ); + mVertBlurTask.FinishedSignal().Connect(this, &GaussianBlurView::OnRenderTaskFinished); } // use the completed blur in the first buffer and composite with the original child actors render if(!mBlurUserImage) { mCompositeTask = taskList.CreateTask(); - mCompositeTask.SetSourceActor( mImageViewComposite ); + mCompositeTask.SetSourceActor(mCompositingActor); mCompositeTask.SetExclusive(true); - mCompositeTask.SetInputEnabled( false ); + mCompositeTask.SetInputEnabled(false); mCompositeTask.SetCameraActor(mRenderFullSizeCamera); - mCompositeTask.SetTargetFrameBuffer( mRenderTargetForRenderingChildren ); + mCompositeTask.SetFrameBuffer(mRenderTargetForRenderingChildren); + + if(mRenderOnce) + { + mCompositeTask.SetRefreshRate(RenderTask::REFRESH_ONCE); + } } } @@ -520,35 +501,43 @@ 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) { // a value of zero leads to undefined Gaussian weights, do not allow user to do this - mBlurBellCurveWidth = std::max( blurBellCurveWidth, 0.001f ); + mBlurBellCurveWidth = std::max(blurBellCurveWidth, 0.001f); } float GaussianBlurView::CalcGaussianWeight(float x) @@ -558,22 +547,22 @@ float GaussianBlurView::CalcGaussianWeight(float x) void GaussianBlurView::SetShaderConstants() { - Vector2 *uvOffsets; - float ofs; - float *weights; - float w, totalWeights; + Vector2* uvOffsets; + float ofs; + float* weights; + float w, totalWeights; unsigned int i; uvOffsets = new Vector2[mNumSamples + 1]; - weights = new float[mNumSamples + 1]; + weights = new float[mNumSamples + 1]; totalWeights = weights[0] = CalcGaussianWeight(0); - uvOffsets[0].x = 0.0f; - uvOffsets[0].y = 0.0f; + uvOffsets[0].x = 0.0f; + uvOffsets[0].y = 0.0f; - for(i=0; i> 1; i++) + for(i = 0; i> 1; i++) { - w = CalcGaussianWeight((float)(i + 1)); + w = CalcGaussianWeight((float)(i + 1)); weights[(i << 1) + 1] = w; weights[(i << 1) + 2] = w; totalWeights += w * 2.0f; @@ -582,8 +571,8 @@ void GaussianBlurView::SetShaderConstants() ofs = ((float)(i << 1)) + 1.5f; // get offsets from units of pixels into uv coordinates in [0..1] - float ofsX = ofs / mDownsampledWidth; - float ofsY = ofs / mDownsampledHeight; + float ofsX = ofs / mDownsampledWidth; + float ofsY = ofs / mDownsampledHeight; uvOffsets[(i << 1) + 1].x = ofsX; uvOffsets[(i << 1) + 1].y = ofsY; @@ -591,7 +580,7 @@ void GaussianBlurView::SetShaderConstants() uvOffsets[(i << 1) + 2].y = -ofsY; } - for(i=0; i