X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fcontrols%2Fbloom-view%2Fbloom-view-impl.cpp;h=ea1b6280f6188d6499271ebbe5abc65bde282a63;hp=c5dfaf80956fbfa6c6225151eaf360ed72cdf604;hb=b1e8521ad77e7b4e62b59613b2edef64429130e9;hpb=3907bd39efa159835ec5456031ec4820934c40cb diff --git a/dali-toolkit/internal/controls/bloom-view/bloom-view-impl.cpp b/dali-toolkit/internal/controls/bloom-view/bloom-view-impl.cpp index c5dfaf8..ea1b6280 100644 --- a/dali-toolkit/internal/controls/bloom-view/bloom-view-impl.cpp +++ b/dali-toolkit/internal/controls/bloom-view/bloom-view-impl.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2014 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,17 +23,18 @@ #include #include #include -#include +#include #include #include -#include +#include #include -#include +#include // INTERNAL INCLUDES -#include +#include #include -#include "../gaussian-blur-view/gaussian-blur-view-impl.h" +#include +#include namespace Dali { @@ -83,8 +84,6 @@ const char* const BLOOM_SATURATION_PROPERTY_NAME = "uBloomSaturation"; const char* const IMAGE_INTENSITY_PROPERTY_NAME = "uImageIntensity"; const char* const IMAGE_SATURATION_PROPERTY_NAME = "uImageSaturation"; -const char* const EFFECT_IMAGE_NAME( "sEffect" ); - /////////////////////////////////////////////////////// // // Bloom shaders @@ -138,47 +137,49 @@ const char* const COMPOSITE_FRAGMENT_SOURCE = BloomView::BloomView() - : Control( ControlBehaviour( ACTOR_BEHAVIOUR_NONE ) ) - , mBlurNumSamples(BLOOM_GAUSSIAN_BLUR_VIEW_DEFAULT_NUM_SAMPLES) - , mBlurBellCurveWidth(BLOOM_GAUSSIAN_BLUR_VIEW_DEFAULT_BLUR_BELL_CURVE_WIDTH) - , mPixelFormat(BLOOM_GAUSSIAN_BLUR_VIEW_DEFAULT_RENDER_TARGET_PIXEL_FORMAT) - , mDownsampleWidthScale(BLOOM_GAUSSIAN_BLUR_VIEW_DEFAULT_DOWNSAMPLE_WIDTH_SCALE) - , mDownsampleHeightScale(BLOOM_GAUSSIAN_BLUR_VIEW_DEFAULT_DOWNSAMPLE_HEIGHT_SCALE) - , mDownsampledWidth( 0.0f ) - , mDownsampledHeight( 0.0f ) - , mTargetSize(Vector2::ZERO) - , mLastSize(Vector2::ZERO) - , mChildrenRoot(Actor::New()) - , mBloomThresholdPropertyIndex(Property::INVALID_INDEX) - , mBlurStrengthPropertyIndex(Property::INVALID_INDEX) - , mBloomIntensityPropertyIndex(Property::INVALID_INDEX) - , mBloomSaturationPropertyIndex(Property::INVALID_INDEX) - , mImageIntensityPropertyIndex(Property::INVALID_INDEX) - , mImageSaturationPropertyIndex(Property::INVALID_INDEX) - , mActivated( false ) +: Control( ControlBehaviour( CONTROL_BEHAVIOUR_DEFAULT ) ), + mBlurNumSamples(BLOOM_GAUSSIAN_BLUR_VIEW_DEFAULT_NUM_SAMPLES), + mBlurBellCurveWidth(BLOOM_GAUSSIAN_BLUR_VIEW_DEFAULT_BLUR_BELL_CURVE_WIDTH), + mPixelFormat(BLOOM_GAUSSIAN_BLUR_VIEW_DEFAULT_RENDER_TARGET_PIXEL_FORMAT), + mDownsampleWidthScale(BLOOM_GAUSSIAN_BLUR_VIEW_DEFAULT_DOWNSAMPLE_WIDTH_SCALE), + mDownsampleHeightScale(BLOOM_GAUSSIAN_BLUR_VIEW_DEFAULT_DOWNSAMPLE_HEIGHT_SCALE), + mDownsampledWidth( 0.0f ), + mDownsampledHeight( 0.0f ), + mTargetSize(Vector2::ZERO), + mLastSize(Vector2::ZERO), + mChildrenRoot(Actor::New()), + mInternalRoot(Actor::New() ), + mBloomThresholdPropertyIndex(Property::INVALID_INDEX), + mBlurStrengthPropertyIndex(Property::INVALID_INDEX), + mBloomIntensityPropertyIndex(Property::INVALID_INDEX), + mBloomSaturationPropertyIndex(Property::INVALID_INDEX), + mImageIntensityPropertyIndex(Property::INVALID_INDEX), + mImageSaturationPropertyIndex(Property::INVALID_INDEX), + mActivated( false ) { } BloomView::BloomView( const unsigned int blurNumSamples, const float blurBellCurveWidth, const Pixel::Format renderTargetPixelFormat, const float downsampleWidthScale, const float downsampleHeightScale) - : Control( ControlBehaviour( ACTOR_BEHAVIOUR_NONE ) ) - , mBlurNumSamples(blurNumSamples) - , mBlurBellCurveWidth(blurBellCurveWidth) - , mPixelFormat(renderTargetPixelFormat) - , mDownsampleWidthScale(downsampleWidthScale) - , mDownsampleHeightScale(downsampleHeightScale) - , mDownsampledWidth( 0.0f ) - , mDownsampledHeight( 0.0f ) - , mTargetSize(Vector2::ZERO) - , mLastSize(Vector2::ZERO) - , mChildrenRoot(Actor::New()) - , mBloomThresholdPropertyIndex(Property::INVALID_INDEX) - , mBlurStrengthPropertyIndex(Property::INVALID_INDEX) - , mBloomIntensityPropertyIndex(Property::INVALID_INDEX) - , mBloomSaturationPropertyIndex(Property::INVALID_INDEX) - , mImageIntensityPropertyIndex(Property::INVALID_INDEX) - , mImageSaturationPropertyIndex(Property::INVALID_INDEX) - , mActivated( false ) +: Control( ControlBehaviour( CONTROL_BEHAVIOUR_DEFAULT ) ), + mBlurNumSamples(blurNumSamples), + mBlurBellCurveWidth(blurBellCurveWidth), + mPixelFormat(renderTargetPixelFormat), + mDownsampleWidthScale(downsampleWidthScale), + mDownsampleHeightScale(downsampleHeightScale), + mDownsampledWidth( 0.0f ), + mDownsampledHeight( 0.0f ), + mTargetSize(Vector2::ZERO), + mLastSize(Vector2::ZERO), + mChildrenRoot(Actor::New()), + mInternalRoot(Actor::New()), + mBloomThresholdPropertyIndex(Property::INVALID_INDEX), + mBlurStrengthPropertyIndex(Property::INVALID_INDEX), + mBloomIntensityPropertyIndex(Property::INVALID_INDEX), + mBloomSaturationPropertyIndex(Property::INVALID_INDEX), + mImageIntensityPropertyIndex(Property::INVALID_INDEX), + mImageSaturationPropertyIndex(Property::INVALID_INDEX), + mActivated( false ) { } @@ -213,24 +214,6 @@ Toolkit::BloomView BloomView::New(const unsigned int blurNumSamples, const float 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 -// 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. -void BloomView::Add(Actor child) -{ - mChildrenRoot.Add(child); -} - -void BloomView::Remove(Actor child) -{ - mChildrenRoot.Remove(child); -} - - - - - - /////////////////////////////////////////////////////////// // // Private methods @@ -239,65 +222,53 @@ void BloomView::Remove(Actor child) void BloomView::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.SetPositionInheritanceMode( Dali::USE_PARENT_POSITION ); + mChildrenRoot.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER ); + mInternalRoot.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER ); ////////////////////////////////////////////////////// // Create actors - // Create an ImageActor for rendering from the scene texture to the bloom texture - mBloomExtractImageActor = Toolkit::ImageView::New(); - mBloomExtractImageActor.SetPositionInheritanceMode( Dali::USE_PARENT_POSITION ); + // Create an image view for rendering from the scene texture to the bloom texture + mBloomExtractActor = Actor::New(); + mBloomExtractActor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER ); - // Create shader used for extracting the bright parts of an image - Property::Map customShader; - customShader[ "fragmentShader" ] = BLOOM_EXTRACT_FRAGMENT_SOURCE; - Property::Map rendererMap; - rendererMap.Insert( "rendererType", "imageRenderer" ); - rendererMap.Insert( "shader", customShader ); - mBloomExtractImageActor.SetProperty( Toolkit::ImageView::Property::IMAGE, rendererMap ); - - // Create an ImageActor for compositing the result (scene and bloom textures) to output - mCompositeImageActor = Toolkit::ImageView::New(); - mCompositeImageActor.SetPositionInheritanceMode( Dali::USE_PARENT_POSITION ); - - // Create shader used to composite bloom and original image to output render target - customShader[ "fragmentShader" ] = COMPOSITE_FRAGMENT_SOURCE; - rendererMap[ "shader" ] = customShader; - mCompositeImageActor.SetProperty( Toolkit::ImageView::Property::IMAGE, rendererMap ); - - // Create an ImageActor for holding final result, i.e. the blurred image. This will get rendered to screen later, via default / user render task - mTargetImageActor = Toolkit::ImageView::New(); - mTargetImageActor.SetPositionInheritanceMode( Dali::USE_PARENT_POSITION ); + // Create an image view for compositing the result (scene and bloom textures) to output + mCompositeActor = Actor::New(); + mCompositeActor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER ); + // 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 = Actor::New(); + mTargetActor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER ); // Create the Gaussian Blur object + render tasks // Note that we use mBloomExtractTarget as the source image and also re-use this as the gaussian blur final render target. This saves the gaussian blur code from creating it // render targets etc internally, so we make better use of resources // Note, this also internally creates the render tasks used by the Gaussian blur, this must occur after the bloom extraction and before the compositing mGaussianBlurView = Dali::Toolkit::GaussianBlurView::New(mBlurNumSamples, mBlurBellCurveWidth, mPixelFormat, mDownsampleWidthScale, mDownsampleHeightScale, true); - mGaussianBlurView.SetPositionInheritanceMode( Dali::USE_PARENT_POSITION ); + mGaussianBlurView.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER ); ////////////////////////////////////////////////////// // Create cameras for the renders corresponding to the (potentially downsampled) render targets' size mRenderDownsampledCamera = CameraActor::New(); - mRenderDownsampledCamera.SetParentOrigin(ParentOrigin::CENTER); + mRenderDownsampledCamera.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER ); mRenderDownsampledCamera.SetInvertYAxis( true ); mRenderFullSizeCamera = CameraActor::New(); - mRenderFullSizeCamera.SetParentOrigin(ParentOrigin::CENTER); + mRenderFullSizeCamera.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER ); mRenderFullSizeCamera.SetInvertYAxis( true ); //////////////////////////////// // Connect to actor tree Self().Add( mChildrenRoot ); - Self().Add( mBloomExtractImageActor ); - Self().Add( mGaussianBlurView ); - Self().Add( mCompositeImageActor ); - Self().Add( mTargetImageActor ); - Self().Add( mRenderDownsampledCamera ); - Self().Add( mRenderFullSizeCamera ); + Self().Add( mInternalRoot ); + mInternalRoot.Add( mBloomExtractActor ); + mInternalRoot.Add( mGaussianBlurView ); + mInternalRoot.Add( mCompositeActor ); + mInternalRoot.Add( mTargetActor ); + mInternalRoot.Add( mRenderDownsampledCamera ); + mInternalRoot.Add( mRenderFullSizeCamera ); // bind properties for / set shader constants to defaults SetupProperties(); @@ -306,9 +277,9 @@ void BloomView::OnInitialize() void BloomView::OnSizeSet(const Vector3& targetSize) { mTargetSize = Vector2(targetSize); - mChildrenRoot.SetSize(targetSize); - mCompositeImageActor.SetSize(targetSize); - mTargetImageActor.SetSize(targetSize); + mChildrenRoot.SetProperty( Actor::Property::SIZE, targetSize); + mCompositeActor.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 @@ -318,7 +289,7 @@ void BloomView::OnSizeSet(const Vector3& targetSize) // 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) @@ -326,12 +297,31 @@ void BloomView::OnSizeSet(const Vector3& targetSize) Deactivate(); Activate(); } + + Control::OnSizeSet( targetSize ); +} + +void BloomView::OnChildAdd( Actor& child ) +{ + if( child != mChildrenRoot && child != mInternalRoot) + { + mChildrenRoot.Add( child ); + } + + Control::OnChildAdd( child ); +} + +void BloomView::OnChildRemove( Actor& child ) +{ + mChildrenRoot.Remove( child ); + + Control::OnChildRemove( child ); } void BloomView::AllocateResources() { // size of render targets etc is based on the size of this actor, ignoring z - if(mTargetSize != mLastSize) + if(mTargetSize != mLastSize || !mActivated) { mLastSize = mTargetSize; @@ -345,63 +335,71 @@ void BloomView::AllocateResources() // 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 ) ) ) ); // 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); + mRenderFullSizeCamera.SetProperty( Actor::Property::POSITION, Vector3( 0.0f, 0.0f, mTargetSize.height * cameraPosConstraintScale ) ); ////////////////////////////////////////////////////// // Pass size change onto GaussianBlurView, so it matches - mGaussianBlurView.SetSize(mTargetSize); + mGaussianBlurView.SetProperty( Actor::Property::SIZE, mTargetSize ); GetImpl(mGaussianBlurView).AllocateResources(); + mGaussianBlurView.SetProperty( Actor::Property::VISIBLE, true ); ////////////////////////////////////////////////////// // Create render targets // create off screen buffer of new size to render our child actors to - mRenderTargetForRenderingChildren = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Dali::Image::UNUSED ); - mBloomExtractTarget = FrameBufferImage::New( mDownsampledWidth, mDownsampledHeight, mPixelFormat, Dali::Image::UNUSED ); - FrameBufferImage mBlurExtractTarget = FrameBufferImage::New( mDownsampledWidth, mDownsampledHeight, mPixelFormat, Dali::Image::UNUSED ); - mOutputRenderTarget = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Dali::Image::UNUSED); + mRenderTargetForRenderingChildren = FrameBuffer::New( mTargetSize.width, mTargetSize.height, FrameBuffer::Attachment::NONE ); + Texture textureForChildren = Texture::New( TextureType::TEXTURE_2D, mPixelFormat, unsigned(mTargetSize.width), unsigned(mTargetSize.height) ); + mRenderTargetForRenderingChildren.AttachColorTexture( textureForChildren ); + + mBloomExtractTarget = FrameBuffer::New( mDownsampledWidth, mDownsampledHeight, FrameBuffer::Attachment::NONE ); + Texture texture = Texture::New( TextureType::TEXTURE_2D, mPixelFormat, unsigned(mDownsampledWidth), unsigned(mDownsampledHeight) ); + mBloomExtractTarget.AttachColorTexture( texture ); + + FrameBuffer blurExtractTarget = FrameBuffer::New( mDownsampledWidth, mDownsampledHeight, FrameBuffer::Attachment::NONE ); + texture = Texture::New( TextureType::TEXTURE_2D, mPixelFormat, unsigned(mDownsampledWidth), unsigned(mDownsampledHeight) ); + blurExtractTarget.AttachColorTexture( texture ); + mOutputRenderTarget = FrameBuffer::New( mTargetSize.width, mTargetSize.height, FrameBuffer::Attachment::NONE ); + Texture outputTexture = Texture::New( TextureType::TEXTURE_2D, mPixelFormat, unsigned(mTargetSize.width), unsigned(mTargetSize.height) ); + mOutputRenderTarget.AttachColorTexture( outputTexture ); ////////////////////////////////////////////////////// // Point actors and render tasks at new render targets - mBloomExtractImageActor.SetImage( mRenderTargetForRenderingChildren ); - mBloomExtractImageActor.SetSize(mDownsampledWidth, mDownsampledHeight); // size needs to match render target + Renderer bloomRenderer = CreateRenderer( BASIC_VERTEX_SOURCE, BLOOM_EXTRACT_FRAGMENT_SOURCE ); + SetRendererTexture( bloomRenderer, mRenderTargetForRenderingChildren ); + mBloomExtractActor.AddRenderer( bloomRenderer ); + mBloomExtractActor.SetProperty( Actor::Property::SIZE, Vector2( mDownsampledWidth, mDownsampledHeight ) ); // size needs to match render target // set GaussianBlurView to blur our extracted bloom - mGaussianBlurView.SetUserImageAndOutputRenderTarget(mBloomExtractTarget, mBlurExtractTarget); + mGaussianBlurView.SetUserImageAndOutputRenderTarget( mBloomExtractTarget.GetColorTexture(), blurExtractTarget ); // use the completed blur in the first buffer and composite with the original child actors render - mCompositeImageActor.SetImage( mRenderTargetForRenderingChildren ); - Material material = mCompositeImageActor.GetRendererAt(0).GetMaterial(); - int textureIndex = material.GetTextureIndex( EFFECT_IMAGE_NAME ); - if( textureIndex == -1 ) - { - material.AddTexture( mBlurExtractTarget, EFFECT_IMAGE_NAME ); - } - else - { - material.SetTextureImage( textureIndex, mBlurExtractTarget ); - } + Renderer compositeRenderer = CreateRenderer( BASIC_VERTEX_SOURCE, COMPOSITE_FRAGMENT_SOURCE ); + SetRendererTexture( compositeRenderer, mRenderTargetForRenderingChildren ); + TextureSet textureSet = compositeRenderer.GetTextures(); + textureSet.SetTexture( 0u, mRenderTargetForRenderingChildren.GetColorTexture() ); + textureSet.SetTexture( 1u, blurExtractTarget.GetColorTexture() ); + mCompositeActor.AddRenderer( compositeRenderer ); // set up target actor for rendering result, i.e. the blurred image - mTargetImageActor.SetImage(mOutputRenderTarget); + Renderer targetRenderer = CreateRenderer( BASIC_VERTEX_SOURCE, BASIC_FRAGMENT_SOURCE ); + SetRendererTexture( targetRenderer, mOutputRenderTarget ); + mTargetActor.AddRenderer( targetRenderer ); } } @@ -416,28 +414,28 @@ void BloomView::CreateRenderTasks() mRenderChildrenTask.SetInputEnabled( false ); mRenderChildrenTask.SetClearEnabled( true ); mRenderChildrenTask.SetCameraActor(mRenderFullSizeCamera); // use camera that covers render target exactly - mRenderChildrenTask.SetTargetFrameBuffer( mRenderTargetForRenderingChildren ); + mRenderChildrenTask.SetFrameBuffer( mRenderTargetForRenderingChildren ); // Extract the bright part of the image and render to a new buffer. Downsampling also occurs at this stage to save pixel fill, if it is set up. mBloomExtractTask = taskList.CreateTask(); - mBloomExtractTask.SetSourceActor( mBloomExtractImageActor ); + mBloomExtractTask.SetSourceActor( mBloomExtractActor ); mBloomExtractTask.SetExclusive(true); mBloomExtractTask.SetInputEnabled( false ); mBloomExtractTask.SetClearEnabled( true ); mBloomExtractTask.SetCameraActor(mRenderDownsampledCamera); - mBloomExtractTask.SetTargetFrameBuffer( mBloomExtractTarget ); + mBloomExtractTask.SetFrameBuffer( mBloomExtractTarget ); // GaussianBlurView tasks must be created here, so they are executed in the correct order with respect to BloomView tasks GetImpl(mGaussianBlurView).CreateRenderTasks(); - // Use an image actor displaying the children render and composite it with the blurred bloom buffer, targeting the output + // Use an image view displaying the children render and composite it with the blurred bloom buffer, targeting the output mCompositeTask = taskList.CreateTask(); - mCompositeTask.SetSourceActor( mCompositeImageActor ); + mCompositeTask.SetSourceActor( mCompositeActor ); mCompositeTask.SetExclusive(true); mCompositeTask.SetInputEnabled( false ); mCompositeTask.SetClearEnabled( true ); mCompositeTask.SetCameraActor(mRenderFullSizeCamera); - mCompositeTask.SetTargetFrameBuffer( mOutputRenderTarget ); + mCompositeTask.SetFrameBuffer( mOutputRenderTarget ); } void BloomView::RemoveRenderTasks() @@ -465,6 +463,18 @@ void BloomView::Deactivate() // stop render tasks processing // Note: render target resources are automatically freed since we set the Image::Unused flag RemoveRenderTasks(); + + mRenderTargetForRenderingChildren.Reset(); + mBloomExtractTarget.Reset(); + mOutputRenderTarget.Reset(); + + // Reset children + mBloomExtractActor.RemoveRenderer( 0u ); + mTargetActor.RemoveRenderer( 0u ); + mCompositeActor.RemoveRenderer( 0u ); + + mGaussianBlurView.SetProperty( Actor::Property::VISIBLE, false ); + mActivated = false; } @@ -494,19 +504,19 @@ void BloomView::SetupProperties() // bloom threshold // set defaults, makes sure properties are registered with shader - mBloomExtractImageActor.RegisterProperty( BLOOM_THRESHOLD_PROPERTY_NAME, BLOOM_THRESHOLD_DEFAULT ); - mBloomExtractImageActor.RegisterProperty( RECIP_ONE_MINUS_BLOOM_THRESHOLD_PROPERTY_NAME, 1.0f / (1.0f - BLOOM_THRESHOLD_DEFAULT) ); + mBloomExtractActor.RegisterProperty( BLOOM_THRESHOLD_PROPERTY_NAME, BLOOM_THRESHOLD_DEFAULT ); + mBloomExtractActor.RegisterProperty( RECIP_ONE_MINUS_BLOOM_THRESHOLD_PROPERTY_NAME, 1.0f / (1.0f - BLOOM_THRESHOLD_DEFAULT) ); // Register a property that the user can control to change the bloom threshold mBloomThresholdPropertyIndex = self.RegisterProperty(BLOOM_THRESHOLD_PROPERTY_NAME, BLOOM_THRESHOLD_DEFAULT); - Property::Index shaderBloomThresholdPropertyIndex = mBloomExtractImageActor.GetPropertyIndex(BLOOM_THRESHOLD_PROPERTY_NAME); - Constraint bloomThresholdConstraint = Constraint::New( mBloomExtractImageActor, shaderBloomThresholdPropertyIndex, EqualToConstraint()); + Property::Index shaderBloomThresholdPropertyIndex = mBloomExtractActor.GetPropertyIndex(BLOOM_THRESHOLD_PROPERTY_NAME); + Constraint bloomThresholdConstraint = Constraint::New( mBloomExtractActor, shaderBloomThresholdPropertyIndex, EqualToConstraint()); bloomThresholdConstraint.AddSource( Source(self, mBloomThresholdPropertyIndex) ); bloomThresholdConstraint.Apply(); // precalc 1.0 / (1.0 - threshold) on CPU to save shader insns, using constraint to tie to the normal threshold property - Property::Index shaderRecipOneMinusBloomThresholdPropertyIndex = mBloomExtractImageActor.GetPropertyIndex(RECIP_ONE_MINUS_BLOOM_THRESHOLD_PROPERTY_NAME); - Constraint thresholdConstraint = Constraint::New( mBloomExtractImageActor, shaderRecipOneMinusBloomThresholdPropertyIndex, RecipOneMinusConstraint()); + Property::Index shaderRecipOneMinusBloomThresholdPropertyIndex = mBloomExtractActor.GetPropertyIndex(RECIP_ONE_MINUS_BLOOM_THRESHOLD_PROPERTY_NAME); + Constraint thresholdConstraint = Constraint::New( mBloomExtractActor, shaderRecipOneMinusBloomThresholdPropertyIndex, RecipOneMinusConstraint()); thresholdConstraint.AddSource( LocalSource(shaderBloomThresholdPropertyIndex) ); thresholdConstraint.Apply(); @@ -526,9 +536,9 @@ void BloomView::SetupProperties() // Register a property that the user can control to fade the bloom intensity via internally hidden shader mBloomIntensityPropertyIndex = self.RegisterProperty(BLOOM_INTENSITY_PROPERTY_NAME, BLOOM_INTENSITY_DEFAULT); - mCompositeImageActor.RegisterProperty( BLOOM_INTENSITY_PROPERTY_NAME, BLOOM_INTENSITY_DEFAULT ); - Property::Index shaderBloomIntensityPropertyIndex = mCompositeImageActor.GetPropertyIndex(BLOOM_INTENSITY_PROPERTY_NAME); - Constraint bloomIntensityConstraint = Constraint::New( mCompositeImageActor, shaderBloomIntensityPropertyIndex, EqualToConstraint()); + mCompositeActor.RegisterProperty( BLOOM_INTENSITY_PROPERTY_NAME, BLOOM_INTENSITY_DEFAULT ); + Property::Index shaderBloomIntensityPropertyIndex = mCompositeActor.GetPropertyIndex(BLOOM_INTENSITY_PROPERTY_NAME); + Constraint bloomIntensityConstraint = Constraint::New( mCompositeActor, shaderBloomIntensityPropertyIndex, EqualToConstraint()); bloomIntensityConstraint.AddSource( Source(self, mBloomIntensityPropertyIndex) ); bloomIntensityConstraint.Apply(); @@ -538,9 +548,9 @@ void BloomView::SetupProperties() // Register a property that the user can control to fade the bloom saturation via internally hidden shader mBloomSaturationPropertyIndex = self.RegisterProperty(BLOOM_SATURATION_PROPERTY_NAME, BLOOM_SATURATION_DEFAULT); - mCompositeImageActor.RegisterProperty( BLOOM_SATURATION_PROPERTY_NAME, BLOOM_SATURATION_DEFAULT ); - Property::Index shaderBloomSaturationPropertyIndex = mCompositeImageActor.GetPropertyIndex(BLOOM_SATURATION_PROPERTY_NAME); - Constraint bloomSaturationConstraint = Constraint::New( mCompositeImageActor, shaderBloomSaturationPropertyIndex, EqualToConstraint()); + mCompositeActor.RegisterProperty( BLOOM_SATURATION_PROPERTY_NAME, BLOOM_SATURATION_DEFAULT ); + Property::Index shaderBloomSaturationPropertyIndex = mCompositeActor.GetPropertyIndex(BLOOM_SATURATION_PROPERTY_NAME); + Constraint bloomSaturationConstraint = Constraint::New( mCompositeActor, shaderBloomSaturationPropertyIndex, EqualToConstraint()); bloomSaturationConstraint.AddSource( Source(self, mBloomSaturationPropertyIndex) ); bloomSaturationConstraint.Apply(); @@ -550,9 +560,9 @@ void BloomView::SetupProperties() // Register a property that the user can control to fade the image intensity via internally hidden shader mImageIntensityPropertyIndex = self.RegisterProperty(IMAGE_INTENSITY_PROPERTY_NAME, IMAGE_INTENSITY_DEFAULT); - mCompositeImageActor.RegisterProperty( IMAGE_INTENSITY_PROPERTY_NAME, IMAGE_INTENSITY_DEFAULT ); - Property::Index shaderImageIntensityPropertyIndex = mCompositeImageActor.GetPropertyIndex(IMAGE_INTENSITY_PROPERTY_NAME); - Constraint imageIntensityConstraint = Constraint::New( mCompositeImageActor, shaderImageIntensityPropertyIndex, EqualToConstraint()); + mCompositeActor.RegisterProperty( IMAGE_INTENSITY_PROPERTY_NAME, IMAGE_INTENSITY_DEFAULT ); + Property::Index shaderImageIntensityPropertyIndex = mCompositeActor.GetPropertyIndex(IMAGE_INTENSITY_PROPERTY_NAME); + Constraint imageIntensityConstraint = Constraint::New( mCompositeActor, shaderImageIntensityPropertyIndex, EqualToConstraint()); imageIntensityConstraint.AddSource( Source(self, mImageIntensityPropertyIndex) ); imageIntensityConstraint.Apply(); @@ -562,9 +572,9 @@ void BloomView::SetupProperties() // Register a property that the user can control to fade the image saturation via internally hidden shader mImageSaturationPropertyIndex = self.RegisterProperty(IMAGE_SATURATION_PROPERTY_NAME, IMAGE_SATURATION_DEFAULT); - mCompositeImageActor.RegisterProperty( IMAGE_SATURATION_PROPERTY_NAME, IMAGE_SATURATION_DEFAULT ); - Property::Index shaderImageSaturationPropertyIndex = mCompositeImageActor.GetPropertyIndex(IMAGE_SATURATION_PROPERTY_NAME); - Constraint imageSaturationConstraint = Constraint::New( mCompositeImageActor, shaderImageSaturationPropertyIndex, EqualToConstraint()); + mCompositeActor.RegisterProperty( IMAGE_SATURATION_PROPERTY_NAME, IMAGE_SATURATION_DEFAULT ); + Property::Index shaderImageSaturationPropertyIndex = mCompositeActor.GetPropertyIndex(IMAGE_SATURATION_PROPERTY_NAME); + Constraint imageSaturationConstraint = Constraint::New( mCompositeActor, shaderImageSaturationPropertyIndex, EqualToConstraint()); imageSaturationConstraint.AddSource( Source(self, mImageSaturationPropertyIndex) ); imageSaturationConstraint.Apply(); }