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
, mTargetSize(Vector2::ZERO)
, mLastSize(Vector2::ZERO)
, mChildrenRoot(Actor::New())
+ , mInternalRoot(Actor::New() )
, mBloomThresholdPropertyIndex(Property::INVALID_INDEX)
, mBlurStrengthPropertyIndex(Property::INVALID_INDEX)
, mBloomIntensityPropertyIndex(Property::INVALID_INDEX)
, mTargetSize(Vector2::ZERO)
, mLastSize(Vector2::ZERO)
, mChildrenRoot(Actor::New())
+ , mInternalRoot(Actor::New())
, mBloomThresholdPropertyIndex(Property::INVALID_INDEX)
, mBlurStrengthPropertyIndex(Property::INVALID_INDEX)
, mBloomIntensityPropertyIndex(Property::INVALID_INDEX)
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
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.SetParentOrigin( ParentOrigin::CENTER );
+ mInternalRoot.SetParentOrigin( 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 );
+ mBloomExtractImageActor.SetParentOrigin( ParentOrigin::CENTER );
// Create shader used for extracting the bright parts of an image
Property::Map customShader;
// Create an ImageActor for compositing the result (scene and bloom textures) to output
mCompositeImageActor = Toolkit::ImageView::New();
- mCompositeImageActor.SetPositionInheritanceMode( Dali::USE_PARENT_POSITION );
+ mCompositeImageActor.SetParentOrigin( ParentOrigin::CENTER );
// Create shader used to composite bloom and original image to output render target
customShader[ "fragmentShader" ] = COMPOSITE_FRAGMENT_SOURCE;
// 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 );
-
+ mTargetImageActor.SetParentOrigin( 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.SetParentOrigin( ParentOrigin::CENTER );
//////////////////////////////////////////////////////
////////////////////////////////
// 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( mBloomExtractImageActor );
+ mInternalRoot.Add( mGaussianBlurView );
+ mInternalRoot.Add( mCompositeImageActor );
+ mInternalRoot.Add( mTargetImageActor );
+ mInternalRoot.Add( mRenderDownsampledCamera );
+ mInternalRoot.Add( mRenderFullSizeCamera );
// bind properties for / set shader constants to defaults
SetupProperties();
void BloomView::OnSizeSet(const Vector3& targetSize)
{
+ Control::OnSizeSet( targetSize );
+
mTargetSize = Vector2(targetSize);
mChildrenRoot.SetSize(targetSize);
mCompositeImageActor.SetSize(targetSize);
}
}
+void BloomView::OnChildAdd( Actor& child )
+{
+ Control::OnChildAdd( child );
+
+ if( child != mChildrenRoot && child != mInternalRoot)
+ {
+ mChildrenRoot.Add( 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;
// 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 );
- }
+ TextureSet textureSet = mCompositeImageActor.GetRendererAt(0).GetTextures();
+ textureSet.SetImage( 1u, mBlurExtractTarget );
// set up target actor for rendering result, i.e. the blurred image
mTargetImageActor.SetImage(mOutputRenderTarget);
// 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();
mActivated = false;
}