/*
- * 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.
// EXTERNAL INCLUDES
#include <sstream>
#include <dali/public-api/animation/constraints.h>
-#include <dali/public-api/common/stage.h>
+#include <dali/devel-api/common/stage.h>
+#include <dali/public-api/object/property-map.h>
#include <dali/public-api/render-tasks/render-task-list.h>
+#include <dali/public-api/rendering/renderer.h>
// INTERNAL INCLUDES
+#include <dali-toolkit/internal/controls/control/control-renderers.h>
namespace Dali
{
1.0f/16.0f, 1.0f/16.0f, 1.0f/16.0f, 0.5f/16.0f,
0.5f/16.0f, 0.5f/16.0f, 0.5f/16.0f };
-
-const float ARBITRARY_FIELD_OF_VIEW = Math::PI / 4.0f;
-
const char* BLUR_TWO_PASS_FRAGMENT_SOURCE =
{
"precision highp float;\n"
+ "varying mediump vec2 vTexCoord;\n"
+ "uniform sampler2D sTexture;\n"
"uniform vec2 uSampleOffsets[NUM_SAMPLES];\n"
"uniform float uSampleWeights[NUM_SAMPLES];\n"
"void main()\n"
"{\n"
" vec4 color = vec4(0.0);\n"
- "# ifdef DEBUG_RENDER\n"
- " if( vTexCoord.s < 0.495 )\n"
- " {\n"
- "# endif //def DEBUG_RENDER\n"
- " for( int i = 0; i < NUM_SAMPLES; ++i )\n"
- " {\n"
- " color += texture2D( sTexture, vTexCoord + uSampleOffsets[i] ) * uSampleWeights[i];\n"
- " }\n"
- "# ifdef DEBUG_RENDER\n"
- " }\n"
- " else if( vTexCoord.s > 0.505 )\n"
- " {\n"
- " color = texture2D( sTexture, vTexCoord );\n"
- " }\n"
- " else\n"
+ " for( int i = 0; i < NUM_SAMPLES; ++i )\n"
" {\n"
- " color = vec4( 1.0, 0.0, 0.0, 1.0 );\n"
+ " color += texture2D( sTexture, vTexCoord + uSampleOffsets[i] ) * uSampleWeights[i];\n"
" }\n"
- "# endif //def DEBUG_RENDER\n"
" gl_FragColor = color;\n"
"}\n"
};
const char* BLEND_TWO_IMAGES_FRAGMENT_SOURCE =
{
"precision highp float;\n"
- "uniform float uBlurStrength; \n "
+ "uniform float uBlurStrength;\n "
+ "uniform sampler2D sTexture;\n"
+ "uniform sampler2D sEffect;\n"
+ "varying mediump vec2 vTexCoord;\n"
"void main()\n"
"{\n"
" gl_FragColor = texture2D( sTexture, vTexCoord ) * uBlurStrength"
"}\n"
};
-std::string GetBlurStrengthUniformName()
-{
- return "uBlurStrength";
-}
+const char* const BLUR_STRENGTH_UNIFORM_NAME( "uBlurStrength" );
+const char* const EFFECT_IMAGE_NAME( "sEffect" );
} // namespace
BlurTwoPassFilter::BlurTwoPassFilter()
: ImageFilter()
{
- mShaderForBlending = ShaderEffect::New( "", BLEND_TWO_IMAGES_FRAGMENT_SOURCE );
- mShaderForBlending.SetUniform( GetBlurStrengthUniformName(), 1.f );
- mBlurStrengthPropertyIndex = mShaderForBlending.GetPropertyIndex( GetBlurStrengthUniformName() );
+ // create blending actor and register the property in constructor
+ // to make sure that GetBlurStrengthPropertyIndex() always returns a valid index
+ mActorForBlending = Actor::New();
+ mBlurStrengthPropertyIndex = mActorForBlending.RegisterProperty( BLUR_STRENGTH_UNIFORM_NAME, 1.f );
}
BlurTwoPassFilter::~BlurTwoPassFilter()
void BlurTwoPassFilter::Enable()
{
- mCameraForBlur = CameraActor::New();
- mCameraForBlur.SetParentOrigin(ParentOrigin::CENTER);
+ // create custom shader effect
+ if( !GetKernelSize() )
+ {
+ CreateKernel( DEFAULT_KERNEL4, sizeof(DEFAULT_KERNEL4)/sizeof(DEFAULT_KERNEL4[0]) );
+ }
+ int kernelSize( static_cast< int >(GetKernelSize()) );
+
+ // Set up blur-two-pass custom shader
+ std::ostringstream sstream;
+ sstream << "#define NUM_SAMPLES " << kernelSize << "\n";
+ sstream << BLUR_TWO_PASS_FRAGMENT_SOURCE;
+ std::string fragmentSource( sstream.str() );
// create actor to render input with applied emboss effect
- mActorForInput = ImageActor::New( mInputImage );
- mActorForInput.SetParentOrigin( ParentOrigin::CENTER );
- mActorForInput.SetSize(mTargetSize);
- mActorForInput.ScaleBy( Vector3(1.0f, -1.0f, 1.0f) );
+ mActorForInput = Actor::New();
+ mActorForInput.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ mActorForInput.SetProperty( Actor::Property::SIZE, mTargetSize );
+ Renderer rendererForInput = CreateRenderer( BASIC_VERTEX_SOURCE, fragmentSource.c_str() );
+ SetRendererTexture( rendererForInput, mInputTexture );
+ mActorForInput.AddRenderer( rendererForInput );
// create internal offscreen for result of horizontal pass
- mImageForHorz = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Image::UNUSED );
+ mFrameBufferForHorz = FrameBuffer::New( mTargetSize.width, mTargetSize.height, FrameBuffer::Attachment::NONE );
+ Texture textureForHorz = Texture::New( TextureType::TEXTURE_2D, mPixelFormat, unsigned(mTargetSize.width), unsigned(mTargetSize.height) );
+ mFrameBufferForHorz.AttachColorTexture( textureForHorz );
// create an actor to render mImageForHorz for vertical blur pass
- mActorForHorz = ImageActor::New( mImageForHorz );
- mActorForHorz.SetParentOrigin( ParentOrigin::CENTER );
- mActorForHorz.SetSize(mTargetSize);
- mActorForHorz.ScaleBy( Vector3(1.0f, -1.0f, 1.0f) );
+ mActorForHorz = Actor::New();
+ mActorForHorz.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ mActorForHorz.SetProperty( Actor::Property::SIZE, mTargetSize );
+ Renderer rendererForHorz = CreateRenderer( BASIC_VERTEX_SOURCE, fragmentSource.c_str() );
+ SetRendererTexture( rendererForHorz, textureForHorz );
+ mActorForHorz.AddRenderer( rendererForHorz );
// create internal offscreen for result of the two pass blurred image
- mBlurredImage = FrameBufferImage::New( mTargetSize.width, mTargetSize.height, mPixelFormat, Image::UNUSED);
+ mBlurredFrameBuffer = FrameBuffer::New( mTargetSize.width, mTargetSize.height, FrameBuffer::Attachment::NONE );
+ Texture blurredTexture = Texture::New( TextureType::TEXTURE_2D, mPixelFormat, unsigned(mTargetSize.width), unsigned(mTargetSize.height) );
+ mBlurredFrameBuffer.AttachColorTexture( blurredTexture );
// create an actor to blend the blurred image and the input image with the given blur strength
- mActorForBlending = ImageActor::New( mBlurredImage );
- mActorForBlending.SetParentOrigin( ParentOrigin::CENTER );
- mActorForBlending.SetSize(mTargetSize);
- mActorForBlending.ScaleBy( Vector3(1.0f, -1.0f, 1.0f) );
-
- mRootActor.Add( mActorForInput );
- mRootActor.Add( mActorForHorz );
- mRootActor.Add( mActorForBlending );
- mRootActor.Add( mCameraForBlur );
-
- // create custom shader effect
- if( !GetKernelSize() )
- {
- CreateKernel( DEFAULT_KERNEL4, sizeof(DEFAULT_KERNEL4)/sizeof(DEFAULT_KERNEL4[0]) );
- }
- int kernelSize( static_cast< int >(GetKernelSize()) );
-
- std::ostringstream fragmentSource;
- if( mDebugRender )
- {
- fragmentSource << "#define DEBUG_RENDER\n";
- }
- fragmentSource << "#define NUM_SAMPLES " << kernelSize << "\n";
- fragmentSource << BLUR_TWO_PASS_FRAGMENT_SOURCE;
- mShaderForHorz = ShaderEffect::New( "", fragmentSource.str() );
- mActorForInput.SetShaderEffect( mShaderForHorz );
- mShaderForVert = ShaderEffect::New( "", fragmentSource.str() );
- mActorForHorz.SetShaderEffect( mShaderForVert );
+ Renderer rendererForBlending = CreateRenderer( BASIC_VERTEX_SOURCE, BLEND_TWO_IMAGES_FRAGMENT_SOURCE );
+ TextureSet textureSetForBlending = rendererForBlending.GetTextures();
+ textureSetForBlending.SetTexture( 0u, blurredTexture );
+ textureSetForBlending.SetTexture( 1u, mInputTexture );
+ mActorForBlending.AddRenderer( rendererForBlending );
+ mActorForBlending.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ mActorForBlending.SetProperty( Actor::Property::SIZE, mTargetSize );
for( int i = 0; i < kernelSize; ++i )
{
const std::string offsetUniform( GetOffsetUniformName( i ) );
const std::string weightUniform( GetWeightUniformName( i ) );
- mShaderForHorz.SetUniform( offsetUniform, Vector2(mKernel[i]) * Vector2::XAXIS );
- mShaderForHorz.SetUniform( weightUniform, mKernel[i].z );
+ mActorForInput.RegisterProperty( offsetUniform, Vector2(mKernel[i]) * Vector2::XAXIS );
+ mActorForInput.RegisterProperty( weightUniform, mKernel[i].z );
- mShaderForVert.SetUniform( offsetUniform, Vector2(mKernel[i]) * Vector2::YAXIS );
- mShaderForVert.SetUniform( weightUniform, mKernel[i].z );
+ mActorForHorz.RegisterProperty( offsetUniform, Vector2(mKernel[i]) * Vector2::YAXIS );
+ mActorForHorz.RegisterProperty( weightUniform, mKernel[i].z );
}
- mActorForBlending.SetShaderEffect( mShaderForBlending );
- mShaderForBlending.SetEffectImage( mInputImage );
+ mRootActor.Add( mActorForInput );
+ mRootActor.Add( mActorForHorz );
+ mRootActor.Add( mActorForBlending );
SetupCamera();
CreateRenderTasks();
{
if( mRootActor )
{
- if( mCameraForBlur )
+ if( mCameraActor )
{
- mRootActor.Remove( mCameraForBlur );
- mCameraForBlur.Reset();
+ mRootActor.Remove( mCameraActor );
+ mCameraActor.Reset();
}
if( mActorForInput )
mActorForHorz.Reset();
}
- if( mActorForBlending )
- {
- mRootActor.Remove( mActorForBlending );
- mActorForBlending.Reset();
- }
-
RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
if( mRenderTaskForHorz )
mTargetSize = size;
if( mActorForInput )
{
- mActorForInput.SetSize(mTargetSize);
+ mActorForInput.SetProperty( Actor::Property::SIZE, mTargetSize);
}
if( mActorForHorz )
{
- mActorForHorz.SetSize(mTargetSize);
+ mActorForHorz.SetProperty( Actor::Property::SIZE, mTargetSize);
}
if( mActorForBlending )
{
- mActorForBlending.SetSize(mTargetSize);
+ mActorForBlending.SetProperty( Actor::Property::SIZE, mTargetSize);
}
}
Handle BlurTwoPassFilter::GetHandleForAnimateBlurStrength()
{
- return mShaderForBlending;
-}
-
-void BlurTwoPassFilter::SetupCamera()
-{
- // Create and place a camera for the embossing render, corresponding to its render target size
- mCameraForBlur.SetFieldOfView(ARBITRARY_FIELD_OF_VIEW);
- mCameraForBlur.SetNearClippingPlane(1.0f);
- mCameraForBlur.SetAspectRatio(mTargetSize.width / mTargetSize.height);
- mCameraForBlur.SetType(Dali::Camera::FREE_LOOK); // camera orientation based solely on actor
- mCameraForBlur.SetRotation(Quaternion(M_PI, Vector3::YAXIS));
- mCameraForBlur.SetPosition(0.0f, 0.0f, ((mTargetSize.height * 0.5f) / tanf(ARBITRARY_FIELD_OF_VIEW * 0.5f)));
+ return mActorForBlending;
}
void BlurTwoPassFilter::CreateRenderTasks()
mRenderTaskForHorz.SetInputEnabled( false );
mRenderTaskForHorz.SetClearEnabled( true );
mRenderTaskForHorz.SetClearColor( mBackgroundColor );
- mRenderTaskForHorz.SetTargetFrameBuffer( mImageForHorz );
- mRenderTaskForHorz.SetCameraActor( mCameraForBlur );
+ mRenderTaskForHorz.SetFrameBuffer( mFrameBufferForHorz );
+ mRenderTaskForHorz.SetCameraActor( mCameraActor );
// use the internal buffer and perform a horizontal blur targeting the output buffer
mRenderTaskForVert = taskList.CreateTask();
mRenderTaskForVert.SetInputEnabled( false );
mRenderTaskForVert.SetClearEnabled( true );
mRenderTaskForVert.SetClearColor( mBackgroundColor );
- mRenderTaskForVert.SetTargetFrameBuffer( mBlurredImage );
- mRenderTaskForVert.SetCameraActor( mCameraForBlur );
+ mRenderTaskForVert.SetFrameBuffer( mBlurredFrameBuffer );
+ mRenderTaskForVert.SetCameraActor( mCameraActor );
//Perform a blending between the blurred image and the input image
mRenderTaskForBlending = taskList.CreateTask();
mRenderTaskForBlending.SetInputEnabled( false );
mRenderTaskForBlending.SetClearEnabled( true );
mRenderTaskForBlending.SetClearColor( mBackgroundColor );
- mRenderTaskForBlending.SetTargetFrameBuffer( mOutputImage );
- mRenderTaskForBlending.SetCameraActor( mCameraForBlur );
+ mRenderTaskForBlending.SetFrameBuffer( mOutputFrameBuffer );
+ mRenderTaskForBlending.SetCameraActor( mCameraActor );
}
} // namespace Internal