int UtcDaliMagnifierSetSourceActorP(void)
{
ToolkitTestApplication application;
Stage stage = Stage::GetCurrent();
Magnifier view = Magnifier::New();
stage.Add( view );
application.SendNotification();
application.Render();
RenderTaskList renderTaskList = stage.GetRenderTaskList();
DALI_TEST_CHECK( renderTaskList.GetTaskCount() > 1 );
Actor actor = Actor::New();
stage.Add( actor );
DALI_TEST_CHECK( stage.GetRenderTaskList().GetTask( 1 ).GetSourceActor() != actor );
view.SetSourceActor( actor );
application.SendNotification();
application.Render();
DALI_TEST_EQUALS( stage.GetRenderTaskList().GetTask( 1 ).GetSourceActor(), actor, TEST_LOCATION );
END_TEST;
}
// Positive test case for a method
int UtcDaliShadowViewActivateDeactivate(void)
{
ToolkitTestApplication application;
tet_infoline("UtcDaliShadowViewActivateDeactivate");
Toolkit::ShadowView view = Toolkit::ShadowView::New();
DALI_TEST_CHECK( view );
RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
DALI_TEST_CHECK( 1u == taskList.GetTaskCount() );
view.SetParentOrigin(ParentOrigin::CENTER);
view.SetSize(Stage::GetCurrent().GetSize());
view.Add(Actor::New());
Stage::GetCurrent().Add(view);
view.Activate();
RenderTaskList taskList2 = Stage::GetCurrent().GetRenderTaskList();
DALI_TEST_CHECK( 1u != taskList2.GetTaskCount() );
view.Deactivate();
RenderTaskList taskList3 = Stage::GetCurrent().GetRenderTaskList();
DALI_TEST_CHECK( 1u == taskList3.GetTaskCount() );
END_TEST;
}
int UtcDaliImageActorUseImageAlpha04(void)
{
TestApplication application;
tet_infoline("Testing Dali::RenderableActor::SetUseImageAlpha()");
FrameBufferImage image = FrameBufferImage::New( 100, 50, Pixel::RGBA8888 );
RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
RenderTask task = taskList.GetTask( 0u );
task.SetTargetFrameBuffer( image ); // To ensure frame buffer is connected
application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
application.SendNotification();
application.Render(0);
ImageActor actor = ImageActor::New( image );
application.SendNotification();
application.Render(0);
actor.SetBlendMode( BlendingMode::ON );
actor.SetColor(Vector4(1.0, 1.0, 1.0, 1.0));
actor.SetSize(100, 50);
application.GetGlAbstraction().EnableCullFaceCallTrace(true); // For Enable(GL_BLEND)
Stage::GetCurrent().Add(actor);
application.SendNotification();
application.Render();
const TraceCallStack& callTrace = application.GetGlAbstraction().GetCullFaceTrace();
DALI_TEST_EQUALS( BlendDisabled( callTrace ), false, TEST_LOCATION );
DALI_TEST_EQUALS( BlendEnabled( callTrace), true, TEST_LOCATION );
END_TEST;
}
void SpreadFilter::CreateRenderTasks()
{
RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
// perform a horizontal blur targeting the internal buffer
mRenderTaskForHorz = taskList.CreateTask();
mRenderTaskForHorz.SetRefreshRate( mRefreshOnDemand ? RenderTask::REFRESH_ONCE : RenderTask::REFRESH_ALWAYS );
mRenderTaskForHorz.SetSourceActor( mActorForInput );
mRenderTaskForHorz.SetExclusive(true);
mRenderTaskForHorz.SetInputEnabled( false );
mRenderTaskForHorz.SetClearEnabled( true );
mRenderTaskForHorz.SetClearColor( mBackgroundColor );
mRenderTaskForHorz.SetTargetFrameBuffer( mImageForHorz );
mRenderTaskForHorz.SetCameraActor( mCameraActor );
// use the internal buffer and perform a horizontal blur targeting the output buffer
mRenderTaskForVert = taskList.CreateTask();
mRenderTaskForVert.SetRefreshRate( mRefreshOnDemand ? RenderTask::REFRESH_ONCE : RenderTask::REFRESH_ALWAYS );
mRenderTaskForVert.SetSourceActor( mActorForHorz );
mRenderTaskForVert.SetExclusive(true);
mRenderTaskForVert.SetInputEnabled( false );
mRenderTaskForVert.SetClearEnabled( true );
mRenderTaskForVert.SetClearColor( mBackgroundColor );
mRenderTaskForVert.SetTargetFrameBuffer( mOutputImage );
mRenderTaskForVert.SetCameraActor( mCameraActor );
}
int UtcDaliHitTestAlgorithmOrtho02(void)
{
TestApplication application;
tet_infoline("Testing Dali::HitTestAlgorithm with offset Ortho camera()");
Stage stage = Stage::GetCurrent();
RenderTaskList renderTaskList = stage.GetRenderTaskList();
RenderTask defaultRenderTask = renderTaskList.GetTask(0u);
Dali::CameraActor cameraActor = defaultRenderTask.GetCameraActor();
Vector2 stageSize ( stage.GetSize() );
cameraActor.SetOrthographicProjection(-stageSize.x * 0.3f, stageSize.x * 0.7f,
stageSize.y * 0.3f, -stageSize.y * 0.7f,
800.0f, 4895.0f);
cameraActor.SetPosition(0.0f, 0.0f, 1600.0f);
Vector2 actorSize( stageSize * 0.5f );
// Create two actors with half the size of the stage and set them to be partially overlapping
Actor blue = Actor::New();
blue.SetName( "Blue" );
blue.SetAnchorPoint( AnchorPoint::TOP_LEFT );
blue.SetParentOrigin( Vector3(0.2f, 0.2f, 0.5f) );
blue.SetSize( actorSize );
blue.SetZ(30.0f);
Actor green = Actor::New( );
green.SetName( "Green" );
green.SetAnchorPoint( AnchorPoint::TOP_LEFT );
green.SetParentOrigin( Vector3(0.4f, 0.4f, 0.5f) );
green.SetSize( actorSize );
// Add the actors to the view
stage.Add( blue );
stage.Add( green );
// Render and notify
application.SendNotification();
application.Render(0);
application.Render(10);
HitTestAlgorithm::Results results;
HitTest(stage, Vector2( 240.0f, 400.0f ), results, &DefaultIsActorTouchableFunction);
DALI_TEST_CHECK( results.actor == green );
DALI_TEST_EQUALS( results.actorCoordinates, actorSize * 0.6f, TEST_LOCATION );
HitTest(stage, Vector2::ZERO, results, &DefaultIsActorTouchableFunction);
DALI_TEST_CHECK( results.actor == blue );
DALI_TEST_EQUALS( results.actorCoordinates, Vector2::ZERO, TEST_LOCATION );
HitTest(stage, stageSize, results, &DefaultIsActorTouchableFunction);
DALI_TEST_CHECK( ! results.actor );
DALI_TEST_EQUALS( results.actorCoordinates, Vector2::ZERO, TEST_LOCATION );
// Just inside green
HitTest(stage, stageSize*0.69f, results, &DefaultIsActorTouchableFunction);
DALI_TEST_CHECK( results.actor == green );
DALI_TEST_EQUALS( results.actorCoordinates, actorSize * 0.98f, TEST_LOCATION );
END_TEST;
}
RenderTaskList* RenderTaskList::New( EventThreadServices& eventServices, RenderTaskDefaults& defaults, bool systemLevel )
{
RenderTaskList* taskList = new RenderTaskList( eventServices, defaults, systemLevel );
taskList->Initialize( eventServices.GetUpdateManager() );
return taskList;
}
RenderTaskList* RenderTaskList::New( UpdateManager& updateManager, RenderTaskDefaults& defaults, bool systemLevel )
{
RenderTaskList* taskList = new RenderTaskList( updateManager.GetEventToUpdate(), defaults, systemLevel );
taskList->Initialize( updateManager );
return taskList;
}
void GaussianBlurView::RemoveRenderTasks()
{
RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
taskList.RemoveTask(mRenderChildrenTask);
taskList.RemoveTask(mHorizBlurTask);
taskList.RemoveTask(mVertBlurTask);
taskList.RemoveTask(mCompositeTask);
}
void ShadowView::RemoveRenderTasks()
{
RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
taskList.RemoveTask(mRenderSceneTask);
mRenderSceneTask.Reset();
mBlurFilter.Disable();
}
int UtcDaliRenderTaskListCreateTask(void)
{
TestApplication application;
tet_infoline("Testing RenderTaskList::CreateTask()");
RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
DALI_TEST_CHECK( 1u == taskList.GetTaskCount() );
taskList.CreateTask();
DALI_TEST_CHECK( 2u == taskList.GetTaskCount() );
END_TEST;
}
int UtcDaliRenderTaskListDownCast(void)
{
TestApplication application;
tet_infoline("Testing RenderTaskList::DownCast()");
BaseHandle base = Stage::GetCurrent().GetRenderTaskList();
RenderTaskList taskList = RenderTaskList::DownCast( base );
DALI_TEST_CHECK( taskList );
// Try calling a method
DALI_TEST_CHECK( 1u == taskList.GetTaskCount() );
END_TEST;
}
int UtcDaliBubbleEmitterSetBackground(void)
{
ToolkitTestApplication application;
tet_infoline( " UtcDaliBubbleEmitterSetBackground " );
Image shapeImage = CreateSolidColorImage( application, Color::GREEN, 5, 5 );
BubbleEmitter emitter = BubbleEmitter::New( Vector2(50.f,50.f),shapeImage, 200, Vector2( 5.f, 10.f ));
RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
unsigned int taskCount = taskList.GetTaskCount();
Image bgImage = CreateSolidColorImage( application, Color::RED, 50, 50 );
emitter.SetBackground( bgImage, Vector3(0.f, 0.f, 0.5f) );
DALI_TEST_CHECK( taskList.GetTaskCount() == taskCount+1 );
Wait(application, 500);
DALI_TEST_CHECK( taskList.GetTaskCount() == taskCount );
END_TEST;
}
void Magnifier::InitializeRenderTask()
{
Stage stage = Stage::GetCurrent();
RenderTaskList taskList = stage.GetRenderTaskList();
mTask = taskList.CreateTask();
mTask.SetInputEnabled(false);
mTask.SetClearColor(Vector4(0.5f, 0.5f, 0.5f, 1.0f));
mTask.SetClearEnabled(true);
mCameraActor = CameraActor::New();
mCameraActor.SetType(Camera::FREE_LOOK);
mCameraActor.SetRotation(Quaternion(M_PI, Vector3::YAXIS)); // Look at stage
stage.Add(mCameraActor);
mTask.SetCameraActor( mCameraActor );
SetFrameVisibility(true);
}
void ShadowView::CreateRenderTasks()
{
RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
// We want the first task to render the scene from the light
mRenderSceneTask = taskList.CreateTask();
mRenderSceneTask.SetCameraActor( mCameraActor );
mRenderSceneTask.SetSourceActor( mChildrenRoot );
mRenderSceneTask.SetTargetFrameBuffer( mSceneFromLightRenderTarget );
mRenderSceneTask.SetInputEnabled( false );
mRenderSceneTask.SetClearEnabled( true );
// background color for render task should be the shadow color, but with alpha 0
// we don't want to blend the edges of the content with a BLACK at alpha 0, but
// the same shadow color at alpha 0.
mRenderSceneTask.SetClearColor( mCachedBackgroundColor );
mBlurFilter.Enable();
}
int UtcDaliGaussianBlurViewActivateOnce(void)
{
ToolkitTestApplication application;
tet_infoline("UtcDaliGaussianBlurActivateOnce");
Toolkit::GaussianBlurView view = Toolkit::GaussianBlurView::New(5, 1.5f, Pixel::RGB888, 0.5f, 0.5f, true);
DALI_TEST_CHECK( view );
RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
DALI_TEST_CHECK( 1u == taskList.GetTaskCount() );
view.SetParentOrigin(ParentOrigin::CENTER);
view.SetSize(Stage::GetCurrent().GetSize());
view.Add(Actor::New());
Stage::GetCurrent().Add(view);
view.ActivateOnce();
RenderTaskList taskList2 = Stage::GetCurrent().GetRenderTaskList();
DALI_TEST_CHECK( 1u != taskList2.GetTaskCount() );
application.Render();
END_TEST;
}
void SpreadFilter::Disable()
{
if( mRootActor )
{
if( mCameraActor )
{
mRootActor.Remove( mCameraActor );
mCameraActor.Reset();
}
if( mActorForInput )
{
mRootActor.Remove( mActorForInput );
mActorForInput.Reset();
}
if( mActorForHorz )
{
mRootActor.Remove( mActorForHorz );
mActorForHorz.Reset();
}
RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
if( mRenderTaskForHorz )
{
taskList.RemoveTask(mRenderTaskForHorz);
}
if( mRenderTaskForVert )
{
taskList.RemoveTask(mRenderTaskForVert);
}
mRootActor.Reset();
}
}
void BubbleEmitter::SetBackground( Image bgImage, const Vector3& hsvDelta )
{
mBackgroundImage = bgImage;
mHSVDelta = hsvDelta;
ImageActor sourceActor = ImageActor::New( bgImage );
sourceActor.SetSize( mMovementArea );
sourceActor.SetParentOrigin(ParentOrigin::CENTER);
Stage::GetCurrent().Add( sourceActor );
ShaderEffect colorAdjuster = CreateColorAdjuster( hsvDelta, true /*ignore alpha to make bubble color always*/ );
sourceActor.SetShaderEffect( colorAdjuster );
RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
RenderTask task = taskList.CreateTask();
task.SetRefreshRate( RenderTask::REFRESH_ONCE );
task.SetSourceActor( sourceActor );
task.SetExclusive(true);
task.SetCameraActor(mCameraActor);
task.GetCameraActor().SetInvertYAxis(true);
task.SetTargetFrameBuffer( mEffectImage );
task.FinishedSignal().Connect(this, &BubbleEmitter::OnRenderFinished);
mRenderTaskRunning = true;
}
int UtcDaliHoverOutsideCameraNearFarPlanes(void)
{
TestApplication application;
Stage stage = Stage::GetCurrent();
Vector2 stageSize = stage.GetSize();
Actor actor = Actor::New();
actor.SetSize(100.0f, 100.0f);
actor.SetAnchorPoint(AnchorPoint::CENTER);
actor.SetParentOrigin(ParentOrigin::CENTER);
stage.Add(actor);
// Render and notify
application.SendNotification();
application.Render();
// Get the camera's near and far planes
RenderTaskList taskList = stage.GetRenderTaskList();
Dali::RenderTask task = taskList.GetTask(0);
CameraActor camera = task.GetCameraActor();
float nearPlane = camera.GetNearClippingPlane();
float farPlane = camera.GetFarClippingPlane();
// Calculate the current distance of the actor from the camera
float tanHalfFov = tanf(camera.GetFieldOfView() * 0.5f);
float distance = (stageSize.y * 0.5f) / tanHalfFov;
// Connect to actor's hovered signal
SignalData data;
HoverEventFunctor functor( data );
actor.HoveredSignal().Connect( &application, functor );
Vector2 screenCoordinates( stageSize.x * 0.5f, stageSize.y * 0.5f );
// Emit a started signal
application.ProcessEvent( GenerateSingleHover( TouchPoint::Started, screenCoordinates ) );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
data.Reset();
// Emit a started signal where actor is just at the camera's near plane
actor.SetZ(distance - nearPlane);
// Render and notify
application.SendNotification();
application.Render();
application.ProcessEvent( GenerateSingleHover( TouchPoint::Started, screenCoordinates ) );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
data.Reset();
// Emit a started signal where actor is closer than the camera's near plane
actor.SetZ((distance - nearPlane) + 1.0f);
// Render and notify
application.SendNotification();
application.Render();
application.ProcessEvent( GenerateSingleHover( TouchPoint::Started, screenCoordinates ) );
DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
data.Reset();
// Emit a started signal where actor is just at the camera's far plane
actor.SetZ(distance - farPlane);
// Render and notify
application.SendNotification();
application.Render();
application.ProcessEvent( GenerateSingleHover( TouchPoint::Started, screenCoordinates ) );
DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
data.Reset();
// Emit a started signal where actor is further than the camera's far plane
actor.SetZ((distance - farPlane) - 1.0f);
// Render and notify
application.SendNotification();
application.Render();
application.ProcessEvent( GenerateSingleHover( TouchPoint::Started, screenCoordinates ) );
DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
data.Reset();
END_TEST;
}
int UtcDaliRenderTaskListGetTask(void)
{
TestApplication application;
tet_infoline("Testing RenderTaskList::GetTask()");
RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
RenderTask defaultTask = taskList.GetTask( 0u );
DALI_TEST_CHECK( 1u == taskList.GetTaskCount() );
DALI_TEST_CHECK( defaultTask );
DALI_TEST_CHECK( defaultTask == taskList.GetTask( 0u ) );
RenderTask newTask = taskList.CreateTask();
DALI_TEST_CHECK( 2u == taskList.GetTaskCount() );
RenderTask temp = taskList.GetTask( 0u );
RenderTask temp2 = taskList.GetTask( 1u );
DALI_TEST_CHECK( newTask );
DALI_TEST_CHECK( defaultTask != newTask );
DALI_TEST_CHECK( taskList.GetTask( 0u ) == defaultTask );
DALI_TEST_CHECK( taskList.GetTask( 1u ) == newTask );
DALI_TEST_CHECK( taskList.GetTask( 1u ) != defaultTask );
taskList.RemoveTask( taskList.GetTask(0u) );
DALI_TEST_CHECK( 1u == taskList.GetTaskCount() );
DALI_TEST_CHECK( taskList.GetTask( 0u ) != defaultTask );
DALI_TEST_CHECK( taskList.GetTask( 0u ) == newTask );
END_TEST;
}
void Magnifier::Initialize()
{
Actor self = Self();
mPropertySourcePosition = self.RegisterProperty( Toolkit::Magnifier::SOURCE_POSITION_PROPERTY_NAME, Vector3::ZERO );
Vector2 stageSize(Stage::GetCurrent().GetSize());
Layer dummyLayer = Layer::New();
Stage().GetCurrent().Add(dummyLayer);
dummyLayer.SetParentOrigin(ParentOrigin::CENTER);
// NOTE:
// sourceActor is a dummy delegate actor that takes the source property position,
// and generates a WORLD_POSITION, which is 1 frame behind the source property.
// This way the constraints for determining the camera position (source) and those
// for determining viewport position use the same 1 frame old values.
// A simple i) CameraPos = f(B), ii) B = f(A) set of constraints wont suffice as
// although CameraPos will use B, which is A's previous value. The constraint will
// not realise that B is still dirty as far as constraint (i) is concerned.
// Perhaps this is a bug in the way the constraint system factors into what is dirty
// and what is not.
mSourceActor = Actor::New();
dummyLayer.Add(mSourceActor);
mSourceActor.SetParentOrigin(ParentOrigin::CENTER);
Constraint constraint = Constraint::New<Vector3>( Actor::POSITION,
Source( self, mPropertySourcePosition ),
EqualToConstraint() );
mSourceActor.ApplyConstraint(constraint);
// create the render task this will render content on top of everything
// based on camera source position.
InitializeRenderTask();
// set up some constraints to:
// i) reposition (dest) frame actor based on magnifier actor's world position (this is 1 frame delayed)
// ii) reposition and resize (dest) the render task's viewport based on magnifier actor's world position (1 frame delayed) & size.
// iii) reposition (source) camera actor based on magnifier source actor's world position (this is 1 frame delayed)
// Apply constraint to camera's position
// Position our camera at the same distance from its target as the default camera is.
// The camera position doesn't affect how we render, just what we render (due to near and far clip planes)
// NOTE: We can't interrogate the default camera's position as it is not known initially (takes 1 frame
// for value to update).
// But we can determine the initial position using the same formula:
// distance = stage.height * 0.5 / tan(FOV * 0.5)
RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
RenderTask renderTask = taskList.GetTask(0u);
float fov = renderTask.GetCameraActor().GetFieldOfView();
mDefaultCameraDistance = (stageSize.height * 0.5f) / tanf(fov * 0.5f);
// Use a 1 frame delayed source position to determine the camera actor's position.
// This is necessary as the viewport is determined by the Magnifier's Actor's World position (which is computed
// at the end of the update cycle i.e. after constraints have been applied.)
//Property::Index propertySourcePositionDelayed = mCameraActor.RegisterProperty("delayed-source-position", Vector3::ZERO);
constraint = Constraint::New<Vector3>( Actor::POSITION,
Source( mSourceActor, Actor::WORLD_POSITION ),
CameraActorPositionConstraint(stageSize, mDefaultCameraDistance) );
mCameraActor.ApplyConstraint(constraint);
// Apply constraint to render-task viewport position
constraint = Constraint::New<Vector2>( RenderTask::VIEWPORT_POSITION,
Source( self, Actor::WORLD_POSITION ),//mPropertySourcePosition ),
Source( self, Actor::SIZE ),
Source( self, Actor::WORLD_SCALE),
RenderTaskViewportPositionConstraint(stageSize) );
mTask.ApplyConstraint(constraint);
// Apply constraint to render-task viewport position
constraint = Constraint::New<Vector2>( RenderTask::VIEWPORT_SIZE,
Source( self, Actor::SIZE ),
Source( self, Actor::WORLD_SCALE),
RenderTaskViewportSizeConstraint() );
mTask.ApplyConstraint(constraint);
}
void GaussianBlurView::CreateRenderTasks()
{
RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
if(!mBlurUserImage)
{
// create render task to render our child actors to offscreen buffer
mRenderChildrenTask = taskList.CreateTask();
mRenderChildrenTask.SetSourceActor( mChildrenRoot );
mRenderChildrenTask.SetExclusive(true);
mRenderChildrenTask.SetInputEnabled( false );
mRenderChildrenTask.SetClearEnabled( true );
mRenderChildrenTask.SetClearColor( mBackgroundColor );
mRenderChildrenTask.SetCameraActor(mRenderFullSizeCamera);
mRenderChildrenTask.SetTargetFrameBuffer( mRenderTargetForRenderingChildren );
}
// perform a horizontal blur targeting the second buffer
mHorizBlurTask = taskList.CreateTask();
mHorizBlurTask.SetSourceActor( mImageActorHorizBlur );
mHorizBlurTask.SetExclusive(true);
mHorizBlurTask.SetInputEnabled( false );
mHorizBlurTask.SetClearEnabled( true );
mHorizBlurTask.SetClearColor( mBackgroundColor );
if( 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( mImageActorVertBlur );
mVertBlurTask.SetExclusive(true);
mVertBlurTask.SetInputEnabled( false );
mVertBlurTask.SetClearEnabled( true );
mVertBlurTask.SetClearColor( mBackgroundColor );
if( mRenderOnce && mBlurUserImage )
{
mVertBlurTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
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( mImageActorComposite );
mCompositeTask.SetExclusive(true);
mCompositeTask.SetInputEnabled( false );
mCompositeTask.SetCameraActor(mRenderFullSizeCamera);
mCompositeTask.SetTargetFrameBuffer( mRenderTargetForRenderingChildren );
}
mHorizBlurTask.SetCameraActor(mRenderDownsampledCamera);
mVertBlurTask.SetCameraActor(mRenderDownsampledCamera);
mHorizBlurTask.SetTargetFrameBuffer( mRenderTarget2 );
if(mUserOutputRenderTarget)
{
mVertBlurTask.SetTargetFrameBuffer( mUserOutputRenderTarget );
}
else
{
mVertBlurTask.SetTargetFrameBuffer( mRenderTarget1 );
}
}
int UtcDaliHitTestAlgorithmWithFunctorOnRenderTask(void)
{
TestApplication application;
tet_infoline("Testing Dali::HitTestAlgorithm functor, specific to a given render task");
Stage stage = Stage::GetCurrent();
Size stageSize = stage.GetSize();
RenderTaskList taskList = stage.GetRenderTaskList();
Actor actor[2];
for( int i=0; i<2; i++ )
{
actor[i] = Actor::New();
actor[i].SetSize(100.f, 100.f);
actor[i].SetParentOrigin(ParentOrigin::TOP_LEFT);
actor[i].SetAnchorPoint(AnchorPoint::TOP_LEFT);
actor[i].SetName("HittableActor");
stage.Add(actor[i]);
}
Vector2 position( 50.f, 40.f );
actor[1].SetPosition( position.x, position.y );
RenderTask renderTask[2];
renderTask[0] = taskList.GetTask( 0u );
FrameBufferImage frameBufferImage = FrameBufferImage::New(stageSize.width, stageSize.height, Pixel::A8, Image::Never);
renderTask[1] = taskList.CreateTask();
renderTask[1].SetSourceActor( actor[1] );
renderTask[1].SetExclusive( true );
renderTask[1].SetInputEnabled( true );
renderTask[1].SetTargetFrameBuffer( frameBufferImage );
renderTask[1].SetRefreshRate( RenderTask::REFRESH_ONCE );
renderTask[1].SetScreenToFrameBufferFunction( RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION );
// Render and notify
application.SendNotification();
application.Render();
application.Render();
application.SendNotification();
// Perform a hit-test at the given screen coordinates with different render tasks
Dali::HitTestAlgorithm::Results results;
Vector2 screenCoordinates( 25.f, 25.f );
Dali::HitTestAlgorithm::HitTest( renderTask[0], screenCoordinates, results, IsActorHittableFunction );
DALI_TEST_CHECK( results.actor == actor[0] );
DALI_TEST_EQUALS( screenCoordinates, results.actorCoordinates, 0.1f, TEST_LOCATION );
results.actor = Actor();
results.actorCoordinates = Vector2::ZERO;
Dali::HitTestAlgorithm::HitTest( renderTask[1], screenCoordinates, results, IsActorHittableFunction );
DALI_TEST_CHECK( !results.actor );
DALI_TEST_EQUALS( Vector2::ZERO, results.actorCoordinates, 0.1f, TEST_LOCATION );
screenCoordinates.x = 80.f;
screenCoordinates.y = 70.f;
results.actor = Actor();
results.actorCoordinates = Vector2::ZERO;
Dali::HitTestAlgorithm::HitTest( renderTask[0], screenCoordinates, results, IsActorHittableFunction );
DALI_TEST_CHECK( results.actor == actor[0] );
DALI_TEST_EQUALS( screenCoordinates, results.actorCoordinates, 0.1f, TEST_LOCATION );
results.actor = Actor();
results.actorCoordinates = Vector2::ZERO;
Dali::HitTestAlgorithm::HitTest( renderTask[1], screenCoordinates, results, IsActorHittableFunction );
DALI_TEST_CHECK( results.actor == actor[1]);
DALI_TEST_EQUALS( screenCoordinates - position, results.actorCoordinates, 0.1f, TEST_LOCATION );
screenCoordinates.x = 120.f;
screenCoordinates.y = 130.f;
results.actor = Actor();
results.actorCoordinates = Vector2::ZERO;
Dali::HitTestAlgorithm::HitTest( renderTask[0], screenCoordinates, results, IsActorHittableFunction );
DALI_TEST_CHECK( results.actor == actor[1] );
DALI_TEST_EQUALS( screenCoordinates - position, results.actorCoordinates, 0.1f, TEST_LOCATION );
results.actor = Actor();
results.actorCoordinates = Vector2::ZERO;
Dali::HitTestAlgorithm::HitTest( renderTask[1], screenCoordinates, results, IsActorHittableFunction );
DALI_TEST_CHECK( results.actor == actor[1]);
DALI_TEST_EQUALS( screenCoordinates - position, results.actorCoordinates, 0.1f, TEST_LOCATION );
END_TEST;
}
