automated-tests/src/dali/utc-Dali-RenderTask.cpp

   1 /*
   2  * Copyright (c) 2020 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include <iostream>
  19 #include <stdlib.h>
  20 #include <dali/public-api/dali-core.h>
  21 #include <dali/devel-api/events/hit-test-algorithm.h>
  22 #include <dali-test-suite-utils.h>
  23 #include <dali/integration-api/debug.h>
  24 #include <test-native-image.h>
  25
  26 #include <mesh-builder.h>
  27
  28 #define BOOLSTR(x) ((x)?"T":"F")
  29
  30 //& set: DaliRenderTask
  31
  32 using namespace Dali;
  33
  34 void utc_dali_render_task_startup(void)
  35 {
  36   test_return_value = TET_UNDEF;
  37 }
  38
  39 void utc_dali_render_task_cleanup(void)
  40 {
  41   test_return_value = TET_PASS;
  42 }
  43
  44 /**
  45  * APIs:
  46  *
  47  * Constructor, Destructor, DownCast, New, copy constructor, assignment operator
  48  *
  49  * SetSourceActor                      2+ve, 1-ve
  50  * GetSourceActor                      1+ve, 1-ve
  51  * SetExclusive                        2+ve, 0-ve
  52  * IsExclusive                         2+ve, 0-ve
  53  * SetInputEnabled                     1+ve, 0-ve
  54  * GetInputEnabled                     1+ve, 0-ve
  55  * SetCameraActor                      1+ve, 1-ve
  56  * GetCameraActor                      1+ve, 1-ve
  57  * SetTargetFrameBuffer                1+ve, 1-ve
  58  * GetTargetFrameBuffer                1+ve, 1-ve
  59  * SetScreenToFrameBufferFunction      1+ve, 1-ve
  60  * GetScreenToFrameBufferFunction      1+ve, 1-ve
  61  * SetScreenToFrameBufferMappingActor  1+ve, 1-ve
  62  * GetScreenToFrameBufferMappingActor  1+ve, 1-ve
  63  * SetViewportPosition                 1+ve
  64  * GetCurrentViewportPosition          1+ve
  65  * SetViewportSize                     1+ve
  66  * GetCurrentViewportSize              1+ve
  67  * SetViewport                         2+ve, 1-ve
  68  * GetViewport                         2+ve, 1-ve
  69  * SetClearColor                       1+ve, 1-ve
  70  * GetClearColor                       1+ve, 1-ve
  71  * SetClearEnabled                     1+ve, 1-ve
  72  * GetClearEnabled                     1+ve, 1-ve
  73  * SetCullMode
  74  * GetCullMode
  75  * SetRefreshRate                      Many
  76  * GetRefreshRate                      1+ve
  77  * FinishedSignal                      1+ve
  78  */
  79
  80 namespace // unnamed namespace
  81 {
  82
  83 const int RENDER_FRAME_INTERVAL = 16;                           ///< Duration of each frame in ms. (at approx 60FPS)
  84
  85 /*
  86  * Simulate time passed by.
  87  *
  88  * @note this will always process at least 1 frame (1/60 sec)
  89  *
  90  * @param application Test application instance
  91  * @param duration Time to pass in milliseconds.
  92  * @return The actual time passed in milliseconds
  93  */
  94 int Wait(TestApplication& application, int duration = 0)
  95 {
  96   int time = 0;
  97
  98   for(int i = 0; i <= ( duration / RENDER_FRAME_INTERVAL); i++)
  99   {
 100     application.SendNotification();
 101     application.Render(RENDER_FRAME_INTERVAL);
 102     time += RENDER_FRAME_INTERVAL;
 103   }
 104
 105   return time;
 106 }
 107
 108 struct RenderTaskFinished
 109 {
 110   RenderTaskFinished( bool& finished )
 111   : finished( finished )
 112   {
 113   }
 114
 115   void operator()( RenderTask& renderTask )
 116   {
 117     finished = true;
 118   }
 119
 120   bool& finished;
 121 };
 122
 123 struct RenderTaskFinishedRemoveSource
 124 {
 125   RenderTaskFinishedRemoveSource( bool& finished )
 126   : finished( finished ),
 127     finishedOnce(false)
 128   {
 129   }
 130
 131   void operator()( RenderTask& renderTask )
 132   {
 133     DALI_TEST_CHECK(finishedOnce == false);
 134     finished = true;
 135     finishedOnce = true;
 136     Actor srcActor = renderTask.GetSourceActor();
 137     UnparentAndReset(srcActor);
 138   }
 139
 140   bool& finished;
 141   bool finishedOnce;
 142 };
 143
 144 struct RenderTaskFinishedRenderAgain
 145 {
 146   RenderTaskFinishedRenderAgain( bool& finished )
 147   : finished( finished ),
 148     finishedOnce(false)
 149   {
 150   }
 151
 152   void operator()( RenderTask& renderTask )
 153   {
 154     DALI_TEST_CHECK(finishedOnce == false);
 155     finished = true;
 156     finishedOnce = true;
 157     renderTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
 158   }
 159
 160   bool& finished;
 161   bool finishedOnce;
 162 };
 163
 164
 165 bool TestScreenToFrameBufferFunction( Vector2& coordinates )
 166 {
 167   coordinates = coordinates + Vector2( 1, 2 );
 168
 169   return true;
 170 }
 171
 172 Actor CreateRenderableActorSuccess(TestApplication& application, std::string filename)
 173 {
 174   PrepareResourceImage( application, 80u, 80u, Pixel::RGBA8888 );
 175   Image image = ResourceImage::New(filename);
 176   Actor actor = CreateRenderableActor(image);
 177   actor.SetProperty( Actor::Property::SIZE, Vector2( 80.0f, 80.0f ) );
 178   return actor;
 179 }
 180
 181 Actor CreateRenderableActorFailed(TestApplication& application, std::string filename)
 182 {
 183   Image image = ResourceImage::New(filename);
 184   DALI_TEST_CHECK( image );
 185   Actor actor = CreateRenderableActor(image);
 186   actor.SetProperty( Actor::Property::SIZE, Vector2( 80.0f, 80.0f ) );
 187   return actor;
 188 }
 189
 190 Image CreateResourceImage(TestApplication& application, std::string filename)
 191 {
 192   PrepareResourceImage( application, 80u, 80u, Pixel::RGBA8888 );
 193   Image image = ResourceImage::New(filename);
 194   DALI_TEST_CHECK( image );
 195   return image;
 196 }
 197
 198 RenderTask CreateRenderTask(TestApplication& application,
 199                             CameraActor offscreenCamera,
 200                             Actor rootActor,       // Reset default render task to point at this actor
 201                             Actor secondRootActor, // Source actor
 202                             unsigned int refreshRate,
 203                             bool glSync)
 204 {
 205   // Change main render task to use a different root
 206   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 207   taskList.GetTask(0u).SetSourceActor( rootActor );
 208
 209   FrameBufferImage frameBufferImage;
 210   if( glSync )
 211   {
 212     NativeImageInterfacePtr testNativeImagePtr = TestNativeImage::New(10, 10);
 213     frameBufferImage= FrameBufferImage::New( *(testNativeImagePtr.Get()) );
 214   }
 215   else
 216   {
 217     frameBufferImage = FrameBufferImage::New( 10, 10 );
 218   }
 219
 220   // Don't draw output framebuffer // '
 221
 222   RenderTask newTask = taskList.CreateTask();
 223   newTask.SetCameraActor( offscreenCamera );
 224   newTask.SetSourceActor( secondRootActor );
 225   newTask.SetInputEnabled( false );
 226   newTask.SetClearColor( Vector4( 0.f, 0.f, 0.f, 0.f ) );
 227   newTask.SetClearEnabled( true );
 228   newTask.SetExclusive( true );
 229   newTask.SetRefreshRate( refreshRate );
 230   newTask.SetTargetFrameBuffer( frameBufferImage );
 231   newTask.SetProperty( RenderTask::Property::REQUIRES_SYNC, glSync );
 232   return newTask;
 233 }
 234
 235 bool UpdateRender(TestApplication& application, TraceCallStack& callStack, bool testDrawn, bool& finishedSig, bool testFinished, bool testKeepUpdating, int lineNumber )
 236 {
 237   finishedSig = false;
 238   callStack.Reset();
 239
 240   tet_printf("TestApplication::UpdateRender().\n");
 241
 242   application.Render(16);
 243   application.SendNotification();
 244
 245   bool sigPassed = false;
 246   if( testFinished )
 247   {
 248     sigPassed = finishedSig;
 249   }
 250   else
 251   {
 252     sigPassed = ! finishedSig;
 253   }
 254
 255   bool drawResult = callStack.FindMethod("DrawElements") || callStack.FindMethod("DrawArrays");
 256
 257   bool drawPassed = false;
 258   if( testDrawn )
 259   {
 260     drawPassed = drawResult;
 261   }
 262   else
 263   {
 264     drawPassed = !drawResult;
 265   }
 266
 267   bool keepUpdating = (application.GetUpdateStatus() != 0);
 268   bool keepUpdatingPassed = false;
 269   if( testKeepUpdating )
 270   {
 271     keepUpdatingPassed = keepUpdating;
 272   }
 273   else
 274   {
 275     keepUpdatingPassed = !keepUpdating;
 276   }
 277
 278   bool result = (sigPassed && drawPassed && keepUpdatingPassed);
 279
 280   tet_printf("UpdateRender: Expected: Draw:%s Signal:%s KeepUpdating: %s  Actual: Draw:%s  Signal:%s KeepUpdating: %s  %s, line %d\n",
 281              BOOLSTR(testDrawn), BOOLSTR(testFinished), BOOLSTR(testKeepUpdating),
 282              BOOLSTR(drawResult), BOOLSTR(finishedSig), BOOLSTR(keepUpdating),
 283              result ? "Passed":"Failed",
 284              lineNumber );
 285
 286   return result;
 287 }
 288
 289 } // unnamed namespace
 290
 291
 292 /****************************************************************************************************/
 293 /****************************************************************************************************/
 294 /********************************   TEST CASES BELOW   **********************************************/
 295 /****************************************************************************************************/
 296 /****************************************************************************************************/
 297
 298 int UtcDaliRenderTaskDownCast01(void)
 299 {
 300   TestApplication application;
 301
 302   tet_infoline("Testing RenderTask::DownCast()");
 303
 304   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 305
 306   BaseHandle base = taskList.GetTask( 0u );
 307   DALI_TEST_CHECK( base );
 308
 309   RenderTask task = RenderTask::DownCast( base );
 310   DALI_TEST_CHECK( task );
 311
 312   // Try calling a method
 313   DALI_TEST_CHECK( task.GetSourceActor() );
 314   END_TEST;
 315 }
 316
 317 int UtcDaliRenderTaskDownCast02(void)
 318 {
 319   TestApplication application;
 320
 321   tet_infoline("Testing RenderTask::DownCast()");
 322
 323   Actor actor = Actor::New();
 324
 325   RenderTask task = RenderTask::DownCast( actor );
 326   DALI_TEST_CHECK( ! task );
 327
 328   END_TEST;
 329 }
 330
 331 int UtcDaliRenderTaskSetSourceActorN(void)
 332 {
 333   TestApplication application;
 334   tet_infoline("Testing RenderTask::SetSourceActor() Negative - try with empty actor handle");
 335   Stage stage = Stage::GetCurrent();
 336
 337   Actor srcActor;
 338
 339   RenderTaskList taskList = stage.GetRenderTaskList();
 340   RenderTask renderTask = taskList.CreateTask();
 341   renderTask.SetSourceActor(srcActor);
 342
 343   application.SendNotification();
 344   application.Render();
 345
 346   DALI_TEST_CHECK( ! renderTask.GetSourceActor() );
 347   END_TEST;
 348 }
 349
 350
 351 int UtcDaliRenderTaskSetSourceActorP01(void)
 352 {
 353   TestApplication application;
 354
 355   tet_infoline("Testing RenderTask::SetSourceActor() Positive - check that setting a non-renderable actor stops existing source actor being rendered ");
 356
 357   Stage stage = Stage::GetCurrent();
 358   RenderTaskList taskList = stage.GetRenderTaskList();
 359   RenderTask task = taskList.GetTask( 0u );
 360
 361   Actor actor = task.GetSourceActor();
 362   DALI_TEST_CHECK( actor );
 363
 364   Texture img = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1 );
 365   Actor newActor = CreateRenderableActor( img );
 366   newActor.SetProperty( Actor::Property::SIZE, Vector2( 1.0f, 1.0f ) );
 367   stage.Add( newActor );
 368
 369   Actor nonRenderableActor = Actor::New();
 370   stage.Add( nonRenderableActor );
 371
 372   // Stop the newActor from being rendered by changing the source actor
 373   DALI_TEST_CHECK( nonRenderableActor );
 374   task.SetSourceActor( nonRenderableActor );
 375   DALI_TEST_CHECK( task.GetSourceActor() != actor );
 376   DALI_TEST_CHECK( task.GetSourceActor() == nonRenderableActor );
 377
 378   TestGlAbstraction& gl = application.GetGlAbstraction();
 379   TraceCallStack& drawTrace = gl.GetDrawTrace();
 380   drawTrace.Enable(true);
 381
 382   // Update & Render nothing!
 383   application.GetGlAbstraction().ClearBoundTextures();
 384   application.SendNotification();
 385   application.Render();
 386
 387   // Check that nothing was rendered
 388   DALI_TEST_EQUALS( drawTrace.CountMethod("DrawElements"), 0, TEST_LOCATION );
 389
 390   END_TEST;
 391 }
 392
 393
 394 int UtcDaliRenderTaskSetSourceActorP02(void)
 395 {
 396   TestApplication application;
 397
 398   tet_infoline("Testing RenderTask::SetSourceActor() Positive - check that switching source from a non-renderable to a renderable actor causes the texture to be drawn");
 399
 400   Stage stage = Stage::GetCurrent();
 401
 402   RenderTaskList taskList = stage.GetRenderTaskList();
 403
 404   RenderTask task = taskList.GetTask( 0u );
 405
 406   Actor actor = task.GetSourceActor();
 407   DALI_TEST_CHECK( actor );
 408
 409
 410   Texture img = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1 );
 411   Actor newActor = CreateRenderableActor( img );
 412   newActor.SetProperty( Actor::Property::SIZE, Vector2( 1.0f, 1.0f ) );
 413   stage.Add( newActor );
 414
 415   Actor nonRenderableActor = Actor::New();
 416   stage.Add( nonRenderableActor );
 417
 418   TestGlAbstraction& gl = application.GetGlAbstraction();
 419   TraceCallStack& drawTrace = gl.GetDrawTrace();
 420   drawTrace.Enable(true);
 421
 422   // Stop the newActor from being rendered by changing the source actor
 423   DALI_TEST_CHECK( nonRenderableActor );
 424   task.SetSourceActor( nonRenderableActor );
 425   DALI_TEST_CHECK( task.GetSourceActor() != actor );
 426   DALI_TEST_CHECK( task.GetSourceActor() == nonRenderableActor );
 427
 428   // Update & Render nothing!
 429   application.GetGlAbstraction().ClearBoundTextures();
 430   application.SendNotification();
 431   application.Render();
 432
 433   // Check that nothing was rendered
 434   DALI_TEST_EQUALS( drawTrace.CountMethod("DrawElements"), 0, TEST_LOCATION );
 435   drawTrace.Reset();
 436
 437   // Set newActor as the new source Actor
 438   task.SetSourceActor( newActor );
 439   DALI_TEST_CHECK( task.GetSourceActor() != actor );
 440   DALI_TEST_CHECK( task.GetSourceActor() == newActor );
 441
 442   // Update & Render the newActor
 443   application.GetGlAbstraction().ClearBoundTextures();
 444   application.SendNotification();
 445   application.Render();
 446
 447   // Check that the newActor was rendered
 448   DALI_TEST_EQUALS( drawTrace.CountMethod("DrawElements"), 1, TEST_LOCATION );
 449   END_TEST;
 450 }
 451
 452 int UtcDaliRenderTaskSetSourceActorOffStage(void)
 453 {
 454   TestApplication application;
 455
 456   tet_infoline("Testing RenderTask::SetSourceActor (on/off stage testing)");
 457
 458   Stage stage = Stage::GetCurrent();
 459   RenderTaskList taskList = stage.GetRenderTaskList();
 460   RenderTask task = taskList.GetTask( 0u );
 461
 462   Actor actor = task.GetSourceActor();
 463   DALI_TEST_CHECK( actor );
 464
 465   TestGlAbstraction& gl = application.GetGlAbstraction();
 466   TraceCallStack& drawTrace = gl.GetDrawTrace();
 467   drawTrace.Enable(true);
 468
 469   Texture img = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1 );
 470   Actor newActor = CreateRenderableActor( img );
 471   newActor.SetProperty( Actor::Property::SIZE, Vector2( 1.0f, 1.0f ) );
 472   task.SetSourceActor( newActor );
 473   // Don't add newActor to stage yet   //'
 474
 475   // Update & Render with the actor initially off-stage
 476   application.SendNotification();
 477   application.Render();
 478
 479   // Check that nothing was rendered
 480   DALI_TEST_EQUALS( drawTrace.CountMethod("DrawElements"), 0, TEST_LOCATION );
 481
 482   // Now add to stage
 483   stage.Add( newActor );
 484
 485   // Update & Render with the actor on-stage
 486   application.GetGlAbstraction().ClearBoundTextures();
 487   application.SendNotification();
 488   application.Render();
 489
 490   // Check that the newActor was rendered
 491   DALI_TEST_EQUALS( drawTrace.CountMethod("DrawElements"), 1, TEST_LOCATION );
 492   drawTrace.Reset();
 493
 494   // Now remove from stage
 495   stage.Remove( newActor );
 496
 497   // Update & Render with the actor off-stage
 498   application.SendNotification();
 499   application.Render();
 500   DALI_TEST_EQUALS( drawTrace.CountMethod("DrawElements"), 0, TEST_LOCATION );
 501
 502   END_TEST;
 503 }
 504
 505 int UtcDaliRenderTaskSetSourceActorEmpty(void)
 506 {
 507   TestApplication application;
 508
 509   tet_infoline("Testing RenderTask::SetSourceActor (empty handle case)");
 510
 511   Stage stage = Stage::GetCurrent();
 512   RenderTaskList taskList = stage.GetRenderTaskList();
 513   RenderTask task = taskList.GetTask( 0u );
 514
 515   Actor actor = task.GetSourceActor();
 516   DALI_TEST_CHECK( actor );
 517
 518   Texture img = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1 );
 519   Actor newActor = CreateRenderableActor( img );
 520   newActor.SetProperty( Actor::Property::SIZE, Vector2( 1.0f, 1.0f ) );
 521   stage.Add( newActor );
 522
 523   Actor nonRenderableActor = Actor::New();
 524   stage.Add( nonRenderableActor );
 525
 526   // Set with empty handle
 527   task.SetSourceActor( Actor() );
 528   DALI_TEST_CHECK( ! task.GetSourceActor() );
 529
 530   TestGlAbstraction& gl = application.GetGlAbstraction();
 531   TraceCallStack& drawTrace = gl.GetDrawTrace();
 532   drawTrace.Enable(true);
 533
 534   // Update & Render nothing!
 535   application.SendNotification();
 536   application.Render();
 537
 538   // Check that nothing was rendered
 539   DALI_TEST_EQUALS( drawTrace.CountMethod("DrawElements"), 0, TEST_LOCATION );
 540
 541   // Set with non-empty handle
 542   task.SetSourceActor( newActor );
 543   DALI_TEST_CHECK( task.GetSourceActor() == newActor );
 544
 545   // Update & Render the newActor
 546   application.GetGlAbstraction().ClearBoundTextures();
 547   application.SendNotification();
 548   application.Render();
 549
 550   // Check that the newActor was rendered
 551   DALI_TEST_EQUALS( drawTrace.CountMethod("DrawElements"), 1, TEST_LOCATION );
 552   END_TEST;
 553 }
 554
 555 int UtcDaliRenderTaskSetSourceActorDestroyed(void)
 556 {
 557   TestApplication application;
 558
 559   tet_infoline( "Testing RenderTask::SetSourceActor - Set a source actor and destroy the source actor" );
 560
 561   Stage stage = Stage::GetCurrent();
 562   RenderTaskList taskList = stage.GetRenderTaskList();
 563   RenderTask task = taskList.GetTask( 0u );
 564
 565   Actor actor = task.GetSourceActor();
 566   DALI_TEST_CHECK( actor );
 567
 568   Texture img = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1 );
 569
 570   Actor newActor = CreateRenderableActor( img );
 571   newActor.SetProperty( Actor::Property::SIZE, Vector2( 1.0f, 1.0f ) );
 572   stage.Add( newActor );
 573
 574   task.SetSourceActor( newActor );
 575
 576   DALI_TEST_CHECK( task.GetSourceActor() != actor );
 577   DALI_TEST_CHECK( task.GetSourceActor() == newActor );
 578
 579   application.SendNotification();
 580   application.Render();
 581
 582   // Destroy the source actor
 583   stage.Remove( newActor );
 584   newActor.Reset();
 585
 586   DALI_TEST_CHECK( !task.GetSourceActor() );  // The source actor should be an empty handle.
 587
 588   END_TEST;
 589 }
 590
 591 int UtcDaliRenderTaskGetSourceActorP01(void)
 592 {
 593   TestApplication application;
 594
 595   tet_infoline("Testing RenderTask::GetSourceActor() Check the default render task has a valid source actor");
 596
 597   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 598
 599   RenderTask task = taskList.GetTask( 0u );
 600
 601   Actor actor = task.GetSourceActor();
 602   DALI_TEST_CHECK( actor );
 603
 604   // By default the entire scene should be rendered
 605   Actor root = Stage::GetCurrent().GetLayer( 0 );
 606   DALI_TEST_CHECK( root == actor );
 607   END_TEST;
 608 }
 609
 610 int UtcDaliRenderTaskGetSourceActorP02(void)
 611 {
 612   TestApplication application;
 613
 614   tet_infoline("Testing RenderTask::GetSourceActor() Create a new render task, Add a new actor to the stage and set it as the source of the new render task. Get its source actor and check that it is equivalent to what was set.");
 615
 616   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 617   RenderTask task = taskList.CreateTask();
 618   Actor actor = Actor::New();
 619   Stage::GetCurrent().Add(actor);
 620   task.SetSourceActor( actor );
 621
 622   DALI_TEST_EQUALS( actor, task.GetSourceActor(), TEST_LOCATION );
 623
 624   END_TEST;
 625 }
 626
 627 int UtcDaliRenderTaskGetSourceActorN(void)
 628 {
 629   TestApplication application;
 630
 631   tet_infoline("Testing RenderTask::GetSourceActor() Try with empty handle");
 632
 633   RenderTask task;
 634   try
 635   {
 636     Actor actor = task.GetSourceActor();
 637   }
 638   catch (Dali::DaliException& e)
 639   {
 640     DALI_TEST_PRINT_ASSERT( e );
 641     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
 642   }
 643
 644   END_TEST;
 645 }
 646
 647 int UtcDaliRenderTaskSetExclusive(void)
 648 {
 649   TestApplication application;
 650
 651   tet_infoline("Testing RenderTask::SetExclusive() Check that exclusion works");
 652
 653   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 654
 655   // Manipulate the GenTextures behaviour, to identify different actors
 656
 657   std::vector<GLuint> ids;
 658   ids.push_back( 8 ); // 8 = actor1
 659   ids.push_back( 9 ); // 9 = actor2
 660   ids.push_back( 10 ); // 10 = actor3
 661   application.GetGlAbstraction().SetNextTextureIds( ids );
 662
 663   Texture img1 = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1 );
 664   Actor actor1 = CreateRenderableActor( img1 );
 665   actor1.SetProperty( Actor::Property::SIZE, Vector2( 1.0f, 1.0f ) );
 666   Stage::GetCurrent().Add( actor1 );
 667
 668   // Update & Render actor1
 669   application.SendNotification();
 670   application.Render();
 671
 672   // Check that the actor1 was rendered
 673   const std::vector<GLuint>& boundTextures = application.GetGlAbstraction().GetBoundTextures( GL_TEXTURE0 );
 674   DALI_TEST_GREATER( boundTextures.size(), static_cast<std::vector<GLuint>::size_type>( 0 ), TEST_LOCATION );
 675
 676   if ( boundTextures.size() )
 677   {
 678     int c = 0;
 679     DALI_TEST_EQUALS( boundTextures[c++], 8u/*unique to actor1*/, TEST_LOCATION );
 680     if( boundTextures.size() > 1 )
 681     {
 682       DALI_TEST_EQUALS( boundTextures[c++], 8u/*unique to actor1*/, TEST_LOCATION );
 683     }
 684   }
 685
 686   Texture img2 = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1 );
 687
 688   Actor actor2 = CreateRenderableActor( img2 );
 689   actor2.SetProperty( Actor::Property::SIZE, Vector2( 1.0f, 1.0f ) );
 690
 691   // Force actor2 to be rendered before actor1
 692   Layer layer = Layer::New();
 693   Stage::GetCurrent().Add( layer );
 694   layer.Add( actor2 );
 695   layer.LowerToBottom();
 696
 697   // Update & Render
 698   application.GetGlAbstraction().ClearBoundTextures();
 699   application.SendNotification();
 700   application.Render();
 701
 702   // Check that the actors were rendered
 703   DALI_TEST_GREATER( boundTextures.size(), static_cast<std::vector<GLuint>::size_type>( 1 ), TEST_LOCATION );
 704
 705   if ( boundTextures.size() )
 706   {
 707     int c = 0;
 708     DALI_TEST_EQUALS( boundTextures[c++], 9u/*unique to actor2*/, TEST_LOCATION );
 709     if( boundTextures.size() > 2 )
 710     {
 711       DALI_TEST_EQUALS( boundTextures[c++], 9u/*unique to actor1*/, TEST_LOCATION );
 712     }
 713     DALI_TEST_EQUALS( boundTextures[c++], 8u/*unique to actor1*/, TEST_LOCATION );
 714   }
 715
 716   Texture img3 = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1 );
 717   Actor actor3 = CreateRenderableActor( img3 );
 718   actor3.SetProperty( Actor::Property::SIZE, Vector2( 1.0f, 1.0f ) );
 719
 720   // Force actor3 to be rendered before actor2
 721   layer = Layer::New();
 722   Stage::GetCurrent().Add( layer );
 723   layer.Add( actor3 );
 724   layer.LowerToBottom();
 725
 726   // Update & Render all actors
 727   application.GetGlAbstraction().ClearBoundTextures();
 728   application.SendNotification();
 729   application.Render();
 730
 731   // Check that the actors were rendered
 732   DALI_TEST_GREATER( boundTextures.size(), static_cast<std::vector<GLuint>::size_type>( 2 ), TEST_LOCATION );
 733
 734   if ( boundTextures.size() )
 735   {
 736     int c = 0;
 737     DALI_TEST_EQUALS( boundTextures[c++], 10u/*unique to actor3*/, TEST_LOCATION );
 738     if( boundTextures.size() > 3 )
 739     {
 740       DALI_TEST_EQUALS( boundTextures[c++], 10u/*unique to actor2*/, TEST_LOCATION );
 741     }
 742     DALI_TEST_EQUALS( boundTextures[c++], 9u/*unique to actor2*/, TEST_LOCATION );
 743     DALI_TEST_EQUALS( boundTextures[c++], 8u/*unique to actor1*/, TEST_LOCATION );
 744   }
 745
 746   // Both actors are now connected to the root node
 747   // Setup 2 render-tasks - the first will render from the root-node, and the second from actor2
 748
 749   // Not exclusive is the default
 750   RenderTask task1 = taskList.GetTask( 0u );
 751   DALI_TEST_CHECK( false == task1.IsExclusive() );
 752
 753   RenderTask task2 = taskList.CreateTask();
 754   DALI_TEST_CHECK( false == task2.IsExclusive() );
 755   task2.SetSourceActor( actor2 );
 756
 757   // Task1 should render all actors, and task 2 should render only actor2
 758
 759   application.GetGlAbstraction().ClearBoundTextures();
 760   application.SendNotification();
 761   application.Render();
 762
 763   DALI_TEST_EQUALS( boundTextures.size(), 4u, TEST_LOCATION );
 764
 765   if ( boundTextures.size() == 4 )
 766   {
 767     // Test that task 1 renders actor3, then actor2 & then actor1
 768     DALI_TEST_CHECK( boundTextures[0] == 10u );
 769     DALI_TEST_CHECK( boundTextures[1] == 9u );
 770     DALI_TEST_CHECK( boundTextures[2] == 8u );
 771
 772     // Test that task 2 renders actor2
 773     DALI_TEST_EQUALS( boundTextures[3], 9u, TEST_LOCATION );
 774   }
 775
 776   // Make actor2 exclusive to task2
 777
 778   task2.SetExclusive( true );
 779   DALI_TEST_CHECK( true == task2.IsExclusive() );
 780
 781   // Task1 should render only actor1, and task 2 should render only actor2
 782
 783   application.GetGlAbstraction().ClearBoundTextures();
 784   application.SendNotification();
 785   application.Render();
 786
 787   DALI_TEST_EQUALS( boundTextures.size(), 3u, TEST_LOCATION );
 788   if ( boundTextures.size() == 3 )
 789   {
 790     // Test that task 1 renders actor3 & actor1
 791     DALI_TEST_CHECK( boundTextures[0] == 10u );
 792     DALI_TEST_CHECK( boundTextures[1] == 8u );
 793
 794     // Test that task 2 renders actor2
 795     DALI_TEST_CHECK( boundTextures[2] == 9u );
 796   }
 797
 798   // Create a renderable actor and replace the source actor in task2
 799   auto actor4 = CreateRenderableActor();
 800   task2.SetSourceActor( actor3 );
 801   DALI_TEST_EQUALS( actor3, task2.GetSourceActor(), TEST_LOCATION );
 802
 803   END_TEST;
 804 }
 805
 806 int UtcDaliRenderTaskSetExclusive02(void)
 807 {
 808   TestApplication application;
 809
 810   tet_infoline("Testing RenderTask::SetExclusive() Check that changing from exclusive to not-exclusive works");
 811
 812   std::vector<GLuint> ids;
 813   ids.push_back( 8 ); // 8 = actor1
 814   application.GetGlAbstraction().SetNextTextureIds( ids );
 815
 816   Texture img1 = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1 );
 817   Actor actor1 = CreateRenderableActor( img1 );
 818   actor1.SetProperty( Actor::Property::SIZE, Vector2( 1.0f, 1.0f ) );
 819   Stage::GetCurrent().Add( actor1 );
 820
 821   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 822   RenderTask task = taskList.CreateTask();
 823
 824   task.SetSourceActor( actor1 );
 825   task.SetExclusive(true); // Actor should only render once
 826
 827   TestGlAbstraction& gl = application.GetGlAbstraction();
 828   TraceCallStack& drawTrace = gl.GetDrawTrace();
 829   drawTrace.Enable(true);
 830
 831   // Update & Render actor1
 832   application.SendNotification();
 833   application.Render();
 834
 835   DALI_TEST_EQUALS( drawTrace.CountMethod("DrawElements"), 1, TEST_LOCATION );
 836
 837   // Set task to non-exclusive - actor1 should render twice:
 838   drawTrace.Reset();
 839   task.SetExclusive(false);
 840   application.SendNotification();
 841   application.Render();
 842
 843   DALI_TEST_EQUALS( drawTrace.CountMethod("DrawElements"), 2, TEST_LOCATION );
 844
 845   END_TEST;
 846 }
 847
 848 int UtcDaliRenderTaskSetExclusiveN(void)
 849 {
 850   TestApplication application;
 851
 852   tet_infoline("Testing RenderTask::SetExclusive() on empty handle");
 853
 854   RenderTask task;
 855   try
 856   {
 857     task.SetExclusive(true);
 858   }
 859   catch (Dali::DaliException& e)
 860   {
 861     DALI_TEST_PRINT_ASSERT( e );
 862     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
 863   }
 864   END_TEST;
 865 }
 866
 867 int UtcDaliRenderTaskIsExclusive01(void)
 868 {
 869   TestApplication application;
 870
 871   tet_infoline("Testing RenderTask::IsExclusive() Check default values are non-exclusive");
 872
 873   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 874
 875   // Not exclusive is the default
 876   RenderTask task = taskList.GetTask( 0u );
 877   DALI_TEST_CHECK( false == task.IsExclusive() );
 878
 879   RenderTask newTask = taskList.CreateTask();
 880   DALI_TEST_CHECK( false == newTask.IsExclusive() );
 881
 882   END_TEST;
 883 }
 884
 885 int UtcDaliRenderTaskIsExclusive02(void)
 886 {
 887   TestApplication application;
 888
 889   tet_infoline("Testing RenderTask::IsExclusive() Check the getter returns set values");
 890
 891   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 892
 893   // Not exclusive is the default
 894   RenderTask newTask = taskList.CreateTask();
 895   DALI_TEST_EQUALS( newTask.IsExclusive(), false, TEST_LOCATION );
 896
 897   newTask.SetExclusive(true);
 898   DALI_TEST_EQUALS( newTask.IsExclusive(), true, TEST_LOCATION );
 899   END_TEST;
 900 }
 901
 902 int UtcDaliRenderTaskIsExclusiveN(void)
 903 {
 904   TestApplication application;
 905
 906   tet_infoline("Testing RenderTask::IsExclusive() on empty handle");
 907
 908   RenderTask task;
 909   try
 910   {
 911     bool x = task.IsExclusive();
 912     (void) x;
 913   }
 914   catch (Dali::DaliException& e)
 915   {
 916     DALI_TEST_PRINT_ASSERT( e );
 917     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
 918   }
 919   END_TEST;
 920 }
 921
 922 int UtcDaliRenderTaskSetInputEnabled(void)
 923 {
 924   TestApplication application;
 925
 926   tet_infoline("Testing RenderTask::SetInputEnabled()");
 927
 928   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 929
 930   // Input is enabled by default
 931   RenderTask task = taskList.GetTask( 0u );
 932   DALI_TEST_CHECK( true == task.GetInputEnabled() );
 933
 934   task.SetInputEnabled( false );
 935   DALI_TEST_CHECK( false == task.GetInputEnabled() );
 936
 937   task.SetInputEnabled( true );
 938   DALI_TEST_CHECK( true == task.GetInputEnabled() );
 939   END_TEST;
 940 }
 941
 942 int UtcDaliRenderTaskGetInputEnabled(void)
 943 {
 944   TestApplication application;
 945
 946   tet_infoline("Testing RenderTask::GetInputEnabled()");
 947
 948   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 949
 950   // Input is enabled by default
 951   RenderTask task = taskList.GetTask( 0u );
 952   DALI_TEST_EQUALS( true, task.GetInputEnabled(), TEST_LOCATION );
 953
 954   RenderTask newTask = taskList.CreateTask();
 955   DALI_TEST_EQUALS( true, newTask.GetInputEnabled(), TEST_LOCATION );
 956
 957   newTask.SetInputEnabled(false);
 958   DALI_TEST_EQUALS( false, newTask.GetInputEnabled(), TEST_LOCATION );
 959
 960   END_TEST;
 961 }
 962
 963 int UtcDaliRenderTaskSetCameraActorP(void)
 964 {
 965   TestApplication application;
 966
 967   tet_infoline("Testing RenderTask::SetCameraActor()");
 968
 969   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 970
 971   RenderTask task = taskList.GetTask( 0u );
 972
 973   Actor defaultCameraActor = task.GetCameraActor();
 974   DALI_TEST_CHECK( defaultCameraActor );
 975
 976   CameraActor newCameraActor = CameraActor::New();
 977   DALI_TEST_CHECK( newCameraActor );
 978
 979   task.SetCameraActor( newCameraActor );
 980   DALI_TEST_CHECK( task.GetCameraActor() != defaultCameraActor );
 981   DALI_TEST_EQUALS( task.GetCameraActor(), newCameraActor, TEST_LOCATION );
 982   END_TEST;
 983 }
 984
 985
 986 int UtcDaliRenderTaskSetCameraActorN(void)
 987 {
 988   TestApplication application;
 989
 990   tet_infoline("Testing RenderTask::SetCameraActor() with empty actor handle");
 991
 992   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 993
 994   RenderTask task = taskList.GetTask( 0u );
 995
 996   Actor actor = task.GetCameraActor();
 997   DALI_TEST_CHECK( actor );
 998
 999   CameraActor cameraActor;
1000
1001   task.SetCameraActor( cameraActor );
1002   DALI_TEST_EQUALS( (bool)task.GetCameraActor(), false, TEST_LOCATION );
1003   DALI_TEST_EQUALS( task.GetCameraActor(), cameraActor, TEST_LOCATION );
1004   END_TEST;
1005 }
1006
1007 int UtcDaliRenderTaskSetCameraActorDestroyed(void)
1008 {
1009   TestApplication application;
1010
1011   tet_infoline( "Testing RenderTask::SetCameraActor - Set a camera actor and destroy the camera actor" );
1012
1013   Stage stage = Stage::GetCurrent();
1014   RenderTaskList taskList = stage.GetRenderTaskList();
1015   RenderTask task = taskList.GetTask( 0u );
1016
1017   CameraActor newCameraActor = CameraActor::New();
1018   task.SetCameraActor( newCameraActor );
1019
1020   DALI_TEST_EQUALS( task.GetCameraActor(), newCameraActor, TEST_LOCATION );
1021
1022   // Destroy the camera actor
1023   newCameraActor.Reset();
1024
1025   CameraActor camera = task.GetCameraActor();
1026   DALI_TEST_CHECK( !camera );  // The camera actor should be an empty handle.
1027
1028   END_TEST;
1029 }
1030
1031 int UtcDaliRenderTaskGetCameraActorP(void)
1032 {
1033   TestApplication application;
1034
1035   tet_infoline("Testing RenderTask::GetCameraActor()");
1036
1037   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1038
1039   RenderTask task = taskList.GetTask( 0u );
1040
1041   CameraActor actor = task.GetCameraActor();
1042   DALI_TEST_CHECK( actor );
1043   DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
1044   DALI_TEST_GREATER( actor.GetFieldOfView(), 0.0f, TEST_LOCATION );
1045   END_TEST;
1046 }
1047
1048 int UtcDaliRenderTaskGetCameraActorN(void)
1049 {
1050   TestApplication application;
1051
1052   tet_infoline("Testing RenderTask::GetCameraActor() with empty handle");
1053   RenderTask task;
1054
1055   try
1056   {
1057     Actor actor = task.GetCameraActor();
1058   }
1059   catch (Dali::DaliException& e)
1060   {
1061     DALI_TEST_PRINT_ASSERT( e );
1062     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
1063   }
1064
1065   END_TEST;
1066 }
1067
1068 int UtcDaliRenderTaskSetTargetFrameBufferP(void)
1069 {
1070   TestApplication application;
1071
1072   tet_infoline("Testing RenderTask::SetTargetFrameBuffer()");
1073
1074   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1075
1076   RenderTask task = taskList.GetTask( 0u );
1077
1078   FrameBufferImage newImage = FrameBufferImage::New();
1079   task.SetTargetFrameBuffer( newImage );
1080   DALI_TEST_CHECK( task.GetTargetFrameBuffer() == newImage );
1081   END_TEST;
1082 }
1083
1084 int UtcDaliRenderTaskSetTargetFrameBufferN(void)
1085 {
1086   TestApplication application;
1087
1088   tet_infoline("Testing RenderTask::SetTargetFrameBuffer()");
1089
1090   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1091
1092   RenderTask task = taskList.GetTask( 0u );
1093   FrameBufferImage newImage; // Empty handle
1094   task.SetTargetFrameBuffer( newImage );
1095   DALI_TEST_EQUALS( (bool)task.GetTargetFrameBuffer(), false, TEST_LOCATION );
1096   END_TEST;
1097 }
1098
1099 int UtcDaliRenderTaskGetTargetFrameBufferP(void)
1100 {
1101   TestApplication application;
1102
1103   tet_infoline("Testing RenderTask::GetTargetFrameBuffer()");
1104
1105   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1106
1107   RenderTask newTask = taskList.CreateTask();
1108   FrameBufferImage fb = FrameBufferImage::New(128, 128, Pixel::RGBA8888);
1109   newTask.SetTargetFrameBuffer( fb );
1110   DALI_TEST_EQUALS( newTask.GetTargetFrameBuffer(), fb, TEST_LOCATION );
1111   END_TEST;
1112 }
1113
1114 int UtcDaliRenderTaskGetTargetFrameBufferN(void)
1115 {
1116   TestApplication application;
1117
1118   tet_infoline("Testing RenderTask::GetTargetFrameBuffer()");
1119
1120   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1121
1122   RenderTask task = taskList.GetTask( 0u );
1123
1124   // By default render-tasks do not render off-screen
1125   FrameBufferImage image = task.GetTargetFrameBuffer();
1126   DALI_TEST_CHECK( !image );
1127
1128   END_TEST;
1129 }
1130
1131 int UtcDaliRenderTaskSetFrameBufferP(void)
1132 {
1133   TestApplication application;
1134
1135   tet_infoline("Testing RenderTask::SetFrameBuffer()");
1136
1137   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1138
1139   RenderTask task = taskList.GetTask( 0u );
1140
1141   FrameBuffer newFrameBuffer = FrameBuffer::New( 128u, 128u, FrameBuffer::Attachment::NONE );
1142   task.SetFrameBuffer( newFrameBuffer );
1143   DALI_TEST_CHECK( task.GetFrameBuffer() == newFrameBuffer );
1144   END_TEST;
1145 }
1146
1147 int UtcDaliRenderTaskSetFrameBufferN(void)
1148 {
1149   TestApplication application;
1150
1151   tet_infoline("Testing RenderTask::SetFrameBuffer()");
1152
1153   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1154
1155   RenderTask task = taskList.GetTask( 0u );
1156   FrameBuffer newFrameBuffer; // Empty handle
1157   task.SetFrameBuffer( newFrameBuffer );
1158   DALI_TEST_EQUALS( (bool)task.GetFrameBuffer(), false, TEST_LOCATION );
1159   END_TEST;
1160 }
1161
1162 int UtcDaliRenderTaskGetFrameBufferP(void)
1163 {
1164   TestApplication application;
1165
1166   tet_infoline("Testing RenderTask::GetFrameBuffer()");
1167
1168   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1169
1170   RenderTask task = taskList.GetTask( 0u );
1171
1172   FrameBuffer newFrameBuffer = FrameBuffer::New( 1u, 1u, FrameBuffer::Attachment::NONE  );
1173   task.SetFrameBuffer( newFrameBuffer );
1174   DALI_TEST_CHECK( task.GetFrameBuffer() == newFrameBuffer );
1175   END_TEST;
1176 }
1177
1178 int UtcDaliRenderTaskGetFrameBufferN(void)
1179 {
1180   TestApplication application;
1181
1182   tet_infoline("Testing RenderTask::GetFrameBuffer()");
1183
1184   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1185
1186   RenderTask task = taskList.GetTask( 0u );
1187
1188   // By default render-tasks do not render off-screen
1189   FrameBuffer frameBuffer = task.GetFrameBuffer();
1190   DALI_TEST_CHECK( !frameBuffer );
1191
1192   END_TEST;
1193 }
1194
1195 int UtcDaliRenderTaskSetScreenToFrameBufferFunctionP(void)
1196 {
1197   TestApplication application;
1198
1199   tet_infoline("Testing RenderTask::SetScreenToFrameBufferFunction()");
1200
1201   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1202
1203   RenderTask task = taskList.GetTask( 0u );
1204
1205   task.SetScreenToFrameBufferFunction( TestScreenToFrameBufferFunction );
1206
1207   Vector2 coordinates( 5, 10 );
1208   Vector2 convertedCoordinates( 6, 12 ); // + Vector(1, 2)
1209
1210   RenderTask::ScreenToFrameBufferFunction func = task.GetScreenToFrameBufferFunction();
1211   DALI_TEST_CHECK( func( coordinates ) );
1212   DALI_TEST_CHECK( coordinates == convertedCoordinates );
1213
1214   task.SetScreenToFrameBufferFunction( RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION );
1215   func = task.GetScreenToFrameBufferFunction();
1216   DALI_TEST_CHECK( func( coordinates ) );
1217
1218   task.SetScreenToFrameBufferFunction( RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION );
1219   func = task.GetScreenToFrameBufferFunction();
1220   DALI_TEST_CHECK( ! func( coordinates ) );
1221   END_TEST;
1222 }
1223
1224 int UtcDaliRenderTaskSetScreenToFrameBufferFunctionN(void)
1225 {
1226   TestApplication application;
1227
1228   tet_infoline("Testing RenderTask::SetScreenToFrameBufferFunction()");
1229
1230   RenderTask task; // Empty handle
1231   try
1232   {
1233     task.SetScreenToFrameBufferFunction( TestScreenToFrameBufferFunction );
1234   }
1235   catch (Dali::DaliException& e)
1236   {
1237     DALI_TEST_PRINT_ASSERT( e );
1238     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
1239   }
1240   END_TEST;
1241 }
1242
1243 int UtcDaliRenderTaskGetScreenToFrameBufferFunctionP(void)
1244 {
1245   TestApplication application;
1246
1247   tet_infoline("Testing RenderTask::GetScreenToFrameBufferFunction()");
1248
1249   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1250
1251   RenderTask task = taskList.GetTask( 0u );
1252
1253   Vector2 originalCoordinates( 5, 10 );
1254   Vector2 coordinates( 5, 10 );
1255
1256   RenderTask::ScreenToFrameBufferFunction func = task.GetScreenToFrameBufferFunction();
1257   DALI_TEST_CHECK( !func( coordinates ) ); // conversion should fail by default
1258   DALI_TEST_CHECK( coordinates == originalCoordinates ); // coordinates should not be modified
1259   END_TEST;
1260 }
1261
1262 int UtcDaliRenderTaskGetScreenToFrameBufferFunctionN(void)
1263 {
1264   TestApplication application;
1265
1266   tet_infoline("Testing RenderTask::GetScreenToFrameBufferFunction() on empty handle");
1267
1268   RenderTask task;
1269   try
1270   {
1271     RenderTask::ScreenToFrameBufferFunction func = task.GetScreenToFrameBufferFunction();
1272     (void) func;
1273   }
1274   catch (Dali::DaliException& e)
1275   {
1276     DALI_TEST_PRINT_ASSERT( e );
1277     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
1278   }
1279   END_TEST;
1280 }
1281
1282
1283 int UtcDaliRenderTaskGetScreenToFrameBufferMappingActorP(void)
1284 {
1285   TestApplication application;
1286   tet_infoline("Testing RenderTask::GetScreenToFrameBufferMappingActor ");
1287
1288   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1289   RenderTask renderTask = taskList.CreateTask();
1290   Actor mappingActor = Actor::New();
1291   renderTask.SetScreenToFrameBufferMappingActor(mappingActor);
1292
1293   DALI_TEST_EQUALS( mappingActor, renderTask.GetScreenToFrameBufferMappingActor(), TEST_LOCATION );
1294   END_TEST;
1295 }
1296
1297
1298 int UtcDaliRenderTaskGetScreenToFrameBufferMappingActorN(void)
1299 {
1300   TestApplication application;
1301   tet_infoline("Testing RenderTask::GetScreenToFrameBufferMappingActor with empty task handle");
1302
1303   RenderTask task;
1304   try
1305   {
1306     Actor mappingActor;
1307     task.SetScreenToFrameBufferMappingActor(mappingActor);
1308   }
1309   catch (Dali::DaliException& e)
1310   {
1311     DALI_TEST_PRINT_ASSERT( e );
1312     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
1313   }
1314   END_TEST;
1315 }
1316
1317 int UtcDaliRenderTaskGetScreenToFrameBufferMappingActor02N(void)
1318 {
1319   TestApplication application;
1320   tet_infoline("Testing RenderTask::GetScreenToFrameBufferMappingActor with empty task handle");
1321
1322   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1323   RenderTask renderTask = taskList.CreateTask();
1324   Actor actor;
1325   renderTask.SetScreenToFrameBufferMappingActor(actor);
1326
1327   DALI_TEST_EQUALS( (bool)renderTask.GetScreenToFrameBufferMappingActor(), false, TEST_LOCATION);
1328   END_TEST;
1329 }
1330
1331 int UtcDaliRenderTaskGetViewportP01(void)
1332 {
1333   TestApplication application;
1334
1335   tet_infoline("Testing RenderTask::GetViewport() on default task");
1336
1337   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1338   RenderTask task = taskList.GetTask( 0u );
1339   Viewport viewport = task.GetViewport();
1340
1341   // By default the viewport should match the stage width/height
1342   Vector2 stageSize = Stage::GetCurrent().GetSize();
1343   Viewport expectedViewport( 0, 0, stageSize.width, stageSize.height );
1344   DALI_TEST_CHECK( viewport == expectedViewport );
1345   END_TEST;
1346 }
1347
1348 int UtcDaliRenderTaskGetViewportP02(void)
1349 {
1350   TestApplication application;
1351
1352   tet_infoline("Testing RenderTask::GetViewport() on new task");
1353
1354   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1355   RenderTask task = taskList.CreateTask();
1356   Viewport viewport = task.GetViewport();
1357
1358   // By default the viewport should match the stage width/height
1359   Vector2 stageSize = Stage::GetCurrent().GetSize();
1360   Viewport expectedViewport( 0, 0, stageSize.width, stageSize.height );
1361   DALI_TEST_CHECK( viewport == expectedViewport );
1362   END_TEST;
1363 }
1364
1365 int UtcDaliRenderTaskGetViewportN(void)
1366 {
1367   TestApplication application;
1368
1369   tet_infoline("Testing RenderTask::GetViewport() on empty handle");
1370
1371   RenderTask task;
1372   try
1373   {
1374     Viewport viewport = task.GetViewport();
1375     (void) viewport;
1376   }
1377   catch (Dali::DaliException& e)
1378   {
1379     DALI_TEST_PRINT_ASSERT( e );
1380     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
1381   }
1382   END_TEST;
1383 }
1384
1385
1386 int UtcDaliRenderTaskSetViewportP(void)
1387 {
1388   TestApplication application;
1389
1390   tet_infoline("Testing RenderTask::SetViewport()");
1391
1392   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1393
1394   RenderTask task = taskList.GetTask( 0u );
1395   Vector2 stageSize = Stage::GetCurrent().GetSize();
1396   Viewport newViewport( 0, 0, stageSize.width * 0.5f, stageSize.height * 0.5f );
1397   task.SetViewport( newViewport );
1398
1399   // Update (viewport is a property)
1400   application.SendNotification();
1401   application.Render();
1402
1403   DALI_TEST_CHECK( task.GetViewport() == newViewport );
1404   END_TEST;
1405 }
1406
1407 int UtcDaliRenderTaskSetViewportN(void)
1408 {
1409   TestApplication application;
1410
1411   tet_infoline("Testing RenderTask::SetViewport()");
1412
1413   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1414
1415   RenderTask task;
1416   try
1417   {
1418     Vector2 stageSize = Stage::GetCurrent().GetSize();
1419     Viewport newViewport( 0, 0, stageSize.width * 0.5f, stageSize.height * 0.5f );
1420     task.SetViewport( newViewport );
1421   }
1422   catch (Dali::DaliException& e)
1423   {
1424     DALI_TEST_PRINT_ASSERT( e );
1425     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
1426   }
1427
1428   END_TEST;
1429 }
1430
1431
1432 int UtcDaliRenderTaskSetViewportPosition(void)
1433 {
1434   TestApplication application;
1435
1436   tet_infoline("Testing RenderTask::SetViewportPosition()");
1437
1438   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1439
1440   RenderTask task = taskList.GetTask( 0u );
1441
1442   Viewport viewport = task.GetViewport();
1443
1444   // By default the viewport should match the stage width/height
1445
1446   Vector2 stageSize = Stage::GetCurrent().GetSize();
1447   Viewport expectedViewport( 0, 0, stageSize.width, stageSize.height );
1448   DALI_TEST_CHECK( viewport == expectedViewport );
1449
1450   // 'Setter' test
1451   Vector2 newPosition(25.0f, 50.0f);
1452   task.SetViewportPosition( newPosition );
1453
1454   // Update (viewport is a property)
1455   application.SendNotification();
1456   application.Render();
1457
1458   DALI_TEST_EQUALS( task.GetCurrentViewportPosition(), newPosition, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1459
1460   // Set by Property test
1461   Vector2 newPosition2(32.0f, 32.0f);
1462   task.SetProperty( RenderTask::Property::VIEWPORT_POSITION, newPosition2 );
1463   DALI_TEST_EQUALS( task.GetProperty< Vector2 >( RenderTask::Property::VIEWPORT_POSITION ), newPosition2, TEST_LOCATION );
1464   DALI_TEST_EQUALS( task.GetCurrentProperty< Vector2 >( RenderTask::Property::VIEWPORT_POSITION ), newPosition, TEST_LOCATION ); // still the old position
1465
1466   // Update
1467   application.SendNotification();
1468   application.Render();
1469
1470   DALI_TEST_EQUALS( task.GetCurrentViewportPosition(), newPosition2, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1471   DALI_TEST_EQUALS( task.GetProperty< Vector2 >( RenderTask::Property::VIEWPORT_POSITION ), newPosition2, TEST_LOCATION );
1472   DALI_TEST_EQUALS( task.GetCurrentProperty< Vector2 >( RenderTask::Property::VIEWPORT_POSITION ), newPosition2, TEST_LOCATION );
1473
1474   Vector2 newPosition3(64.0f, 0.0f);
1475   Animation animation = Animation::New(1.0f);
1476   animation.AnimateTo( Property( task, RenderTask::Property::VIEWPORT_POSITION ), newPosition3, AlphaFunction::LINEAR );
1477   animation.Play();
1478
1479   DALI_TEST_EQUALS( task.GetProperty< Vector2 >( RenderTask::Property::VIEWPORT_POSITION ), newPosition3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1480   DALI_TEST_EQUALS( task.GetCurrentProperty< Vector2 >( RenderTask::Property::VIEWPORT_POSITION ), newPosition2, TEST_LOCATION );
1481
1482   // Perform 1000ms worth of updates at which point animation should have completed.
1483   Wait(application, 1000);
1484   DALI_TEST_EQUALS( task.GetCurrentViewportPosition(), newPosition3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1485   DALI_TEST_EQUALS( task.GetCurrentProperty< Vector2 >( RenderTask::Property::VIEWPORT_POSITION ), newPosition3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1486   DALI_TEST_EQUALS( task.GetProperty< Vector2 >( RenderTask::Property::VIEWPORT_POSITION ), newPosition3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1487
1488   // Create another animation which animates by a certain value
1489   const Vector2 newPosition4( 75.0f, 45.0f );
1490   const Vector2 relativePosition( newPosition4 - newPosition3 );
1491   animation = Animation::New( 1.0f );
1492   animation.AnimateBy( Property( task, RenderTask::Property::VIEWPORT_POSITION ), relativePosition );
1493   animation.Play();
1494
1495   DALI_TEST_EQUALS( task.GetProperty< Vector2 >( RenderTask::Property::VIEWPORT_POSITION ), newPosition4, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1496   DALI_TEST_EQUALS( task.GetCurrentProperty< Vector2 >( RenderTask::Property::VIEWPORT_POSITION ), newPosition3, TEST_LOCATION );
1497
1498   // Perform 1000ms worth of updates at which point animation should have completed.
1499   Wait(application, 1000);
1500   DALI_TEST_EQUALS( task.GetCurrentViewportPosition(), newPosition4, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1501   DALI_TEST_EQUALS( task.GetCurrentProperty< Vector2 >( RenderTask::Property::VIEWPORT_POSITION ), newPosition4, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1502   DALI_TEST_EQUALS( task.GetProperty< Vector2 >( RenderTask::Property::VIEWPORT_POSITION ), newPosition4, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1503
1504   END_TEST;
1505 }
1506
1507 int UtcDaliRenderTaskSetViewportSize(void)
1508 {
1509   TestApplication application;
1510
1511   tet_infoline("Testing RenderTask::SetViewportSize()");
1512
1513   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1514
1515   RenderTask task = taskList.GetTask( 0u );
1516
1517   Viewport viewport = task.GetViewport();
1518
1519   // By default the viewport should match the stage width/height
1520
1521   Vector2 stageSize = Stage::GetCurrent().GetSize();
1522   Viewport expectedViewport( 0, 0, stageSize.width, stageSize.height );
1523   DALI_TEST_CHECK( viewport == expectedViewport );
1524
1525   Vector2 newSize(128.0f, 64.0f);
1526   task.SetViewportSize( newSize );
1527
1528   // Update (viewport is a property)
1529   application.SendNotification();
1530   application.Render();
1531
1532   DALI_TEST_EQUALS( task.GetCurrentViewportSize(), newSize, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1533
1534   // Set by Property test
1535   Vector2 newSize2(50.0f, 50.0f);
1536   task.SetProperty( RenderTask::Property::VIEWPORT_SIZE, newSize2 );
1537   DALI_TEST_EQUALS( task.GetProperty< Vector2 >( RenderTask::Property::VIEWPORT_SIZE ), newSize2, TEST_LOCATION );
1538   DALI_TEST_EQUALS( task.GetCurrentProperty< Vector2 >( RenderTask::Property::VIEWPORT_SIZE ), newSize, TEST_LOCATION ); // still the old position
1539
1540   // Update
1541   application.SendNotification();
1542   application.Render();
1543
1544   DALI_TEST_EQUALS( task.GetCurrentViewportSize(), newSize2, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1545   DALI_TEST_EQUALS( task.GetProperty< Vector2 >( RenderTask::Property::VIEWPORT_SIZE ), newSize2, TEST_LOCATION );
1546   DALI_TEST_EQUALS( task.GetCurrentProperty< Vector2 >( RenderTask::Property::VIEWPORT_SIZE ), newSize2, TEST_LOCATION );
1547
1548   Vector2 newSize3(10.0f, 10.0f);
1549   Animation animation = Animation::New(1.0f);
1550   animation.AnimateTo( Property( task, RenderTask::Property::VIEWPORT_SIZE ), newSize3, AlphaFunction::LINEAR );
1551   animation.Play();
1552
1553   DALI_TEST_EQUALS( task.GetProperty< Vector2 >( RenderTask::Property::VIEWPORT_SIZE  ), newSize3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1554   DALI_TEST_EQUALS( task.GetCurrentProperty< Vector2 >( RenderTask::Property::VIEWPORT_SIZE ), newSize2, TEST_LOCATION );
1555
1556   // Perform 1000ms worth of updates at which point animation should have completed.
1557   Wait(application, 1000);
1558   DALI_TEST_EQUALS( task.GetCurrentViewportSize(), newSize3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1559   DALI_TEST_EQUALS( task.GetCurrentProperty< Vector2 >( RenderTask::Property::VIEWPORT_SIZE ), newSize3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1560   DALI_TEST_EQUALS( task.GetProperty< Vector2 >( RenderTask::Property::VIEWPORT_SIZE  ), newSize3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1561
1562   // Create another animation which animates by a certain value
1563   const Vector2 newSize4( 75.0f, 45.0f );
1564   const Vector2 relativeSize( newSize4 - newSize3 );
1565   animation = Animation::New( 1.0f );
1566   animation.AnimateBy( Property( task, RenderTask::Property::VIEWPORT_SIZE ), relativeSize );
1567   animation.Play();
1568
1569   DALI_TEST_EQUALS( task.GetProperty< Vector2 >( RenderTask::Property::VIEWPORT_SIZE ), newSize4, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1570   DALI_TEST_EQUALS( task.GetCurrentProperty< Vector2 >( RenderTask::Property::VIEWPORT_SIZE ), newSize3, TEST_LOCATION );
1571
1572   // Perform 1000ms worth of updates at which point animation should have completed.
1573   Wait(application, 1000);
1574   DALI_TEST_EQUALS( task.GetCurrentViewportSize(), newSize4, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1575   DALI_TEST_EQUALS( task.GetCurrentProperty< Vector2 >( RenderTask::Property::VIEWPORT_SIZE ), newSize4, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1576   DALI_TEST_EQUALS( task.GetProperty< Vector2 >( RenderTask::Property::VIEWPORT_SIZE ), newSize4, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1577
1578   END_TEST;
1579 }
1580
1581 int UtcDaliRenderTaskSetClearColorP(void)
1582 {
1583   TestApplication application;
1584
1585   tet_infoline("Testing RenderTask::SetClearColor()");
1586
1587   Vector4 testColor( 1.0f, 2.0f, 3.0f, 4.0f );
1588   Vector4 testColor2( 5.0f, 6.0f, 7.0f, 8.0f );
1589
1590   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1591
1592   RenderTask task = taskList.GetTask( 0u );
1593   DALI_TEST_CHECK( task.GetClearColor() != testColor );
1594
1595   task.SetClearColor( testColor );
1596
1597   // Wait a frame.
1598   Wait(application);
1599
1600   DALI_TEST_EQUALS( task.GetClearColor(), testColor, TEST_LOCATION );
1601
1602   task.SetProperty( RenderTask::Property::CLEAR_COLOR, testColor2 );
1603   DALI_TEST_EQUALS( task.GetProperty< Vector4 >( RenderTask::Property::CLEAR_COLOR ), testColor2, TEST_LOCATION );
1604   DALI_TEST_EQUALS( task.GetCurrentProperty< Vector4 >( RenderTask::Property::CLEAR_COLOR ), testColor, TEST_LOCATION ); // still the old color
1605
1606   // Wait a frame.
1607   Wait(application);
1608
1609   DALI_TEST_EQUALS( task.GetClearColor(), testColor2, TEST_LOCATION );
1610   DALI_TEST_EQUALS( task.GetProperty< Vector4 >( RenderTask::Property::CLEAR_COLOR ), testColor2, TEST_LOCATION );
1611   DALI_TEST_EQUALS( task.GetCurrentProperty< Vector4 >( RenderTask::Property::CLEAR_COLOR ), testColor2, TEST_LOCATION );
1612
1613   Vector4 newColor3(10.0f, 10.0f, 20.0f, 30.0f);
1614   Animation animation = Animation::New(1.0f);
1615   animation.AnimateTo( Property( task, RenderTask::Property::CLEAR_COLOR ), newColor3, AlphaFunction::LINEAR );
1616   animation.Play();
1617
1618   DALI_TEST_EQUALS( task.GetProperty< Vector4 >( RenderTask::Property::CLEAR_COLOR  ), newColor3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1619   DALI_TEST_EQUALS( task.GetCurrentProperty< Vector4 >( RenderTask::Property::CLEAR_COLOR ), testColor2, TEST_LOCATION );
1620
1621   // Perform 1000ms worth of updates at which point animation should have completed.
1622   Wait(application, 1000);
1623   DALI_TEST_EQUALS( task.GetCurrentProperty< Vector4 >( RenderTask::Property::CLEAR_COLOR ), newColor3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1624   DALI_TEST_EQUALS( task.GetProperty< Vector4 >( RenderTask::Property::CLEAR_COLOR  ), newColor3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1625
1626   // Create another animation which animates by a certain value
1627   const Vector4 newColor4( 0.45f, 0.35f, 0.25f, 0.1f );
1628   const Vector4 relativeColor( newColor4 - newColor3 );
1629   animation = Animation::New( 1.0f );
1630   animation.AnimateBy( Property( task, RenderTask::Property::CLEAR_COLOR ), relativeColor );
1631   animation.Play();
1632
1633   DALI_TEST_EQUALS( task.GetProperty< Vector4 >( RenderTask::Property::CLEAR_COLOR ), newColor4, Math::MACHINE_EPSILON_10, TEST_LOCATION );
1634   DALI_TEST_EQUALS( task.GetCurrentProperty< Vector4 >( RenderTask::Property::CLEAR_COLOR ), newColor3, Math::MACHINE_EPSILON_10, TEST_LOCATION );
1635
1636   // Perform 1000ms worth of updates at which point animation should have completed.
1637   Wait(application, 1000);
1638   DALI_TEST_EQUALS( task.GetCurrentProperty< Vector4 >( RenderTask::Property::CLEAR_COLOR ), newColor4, Math::MACHINE_EPSILON_10, TEST_LOCATION );
1639   DALI_TEST_EQUALS( task.GetProperty< Vector4 >( RenderTask::Property::CLEAR_COLOR ), newColor4, Math::MACHINE_EPSILON_10, TEST_LOCATION );
1640
1641   END_TEST;
1642 }
1643
1644 int UtcDaliRenderTaskSetClearColorN(void)
1645 {
1646   TestApplication application;
1647
1648   tet_infoline("Testing RenderTask::SetClearColor() on empty handle");
1649
1650   RenderTask task;
1651   try
1652   {
1653     task.SetClearColor( Vector4::ZERO );
1654   }
1655   catch (Dali::DaliException& e)
1656   {
1657     DALI_TEST_PRINT_ASSERT( e );
1658     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
1659   }
1660   END_TEST;
1661 }
1662
1663 int UtcDaliRenderTaskGetClearColorP(void)
1664 {
1665   TestApplication application;
1666
1667   tet_infoline("Testing RenderTask::GetClearColor()");
1668
1669   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1670   RenderTask task = taskList.GetTask( 0u );
1671   DALI_TEST_EQUALS( task.GetClearColor(), RenderTask::DEFAULT_CLEAR_COLOR, TEST_LOCATION );
1672   END_TEST;
1673 }
1674
1675 int UtcDaliRenderTaskGetClearColorN(void)
1676 {
1677   TestApplication application;
1678
1679   tet_infoline("Testing RenderTask::GetClearColor()");
1680
1681   RenderTask task;
1682   try
1683   {
1684     Vector4 color = task.GetClearColor();
1685     (void) color;
1686   }
1687   catch (Dali::DaliException& e)
1688   {
1689     DALI_TEST_PRINT_ASSERT( e );
1690     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
1691   }
1692   END_TEST;
1693 }
1694
1695 int UtcDaliRenderTaskSetClearEnabledP(void)
1696 {
1697   TestApplication application;
1698
1699   tet_infoline("Testing RenderTask::SetClearEnabled()");
1700
1701   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1702
1703   RenderTask task = taskList.GetTask( 0u );
1704   DALI_TEST_CHECK( task.GetClearEnabled() ); // defaults to true
1705
1706   task.SetClearEnabled( false );
1707   DALI_TEST_EQUALS( task.GetClearEnabled(), false, TEST_LOCATION );
1708
1709   task.SetClearEnabled( true );
1710   DALI_TEST_EQUALS( task.GetClearEnabled(), true, TEST_LOCATION );
1711   END_TEST;
1712 }
1713
1714 int UtcDaliRenderTaskSetClearEnabledN(void)
1715 {
1716   TestApplication application;
1717
1718   tet_infoline("Testing RenderTask::SetClearEnabled() with empty handle");
1719
1720   RenderTask task;
1721   try
1722   {
1723     task.SetClearEnabled(true);
1724   }
1725   catch (Dali::DaliException& e)
1726   {
1727     DALI_TEST_PRINT_ASSERT( e );
1728     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
1729   }
1730   END_TEST;
1731 }
1732
1733 int UtcDaliRenderTaskGetClearEnabledP(void)
1734 {
1735   TestApplication application;
1736
1737   tet_infoline("Testing RenderTask::GetClearEnabled()");
1738
1739   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1740
1741   RenderTask task = taskList.GetTask( 0u );
1742   DALI_TEST_CHECK( task.GetClearEnabled() ); // defaults to true
1743   END_TEST;
1744 }
1745
1746
1747 int UtcDaliRenderTaskGetClearEnabledN(void)
1748 {
1749   TestApplication application;
1750
1751   tet_infoline("Testing RenderTask::GetClearEnabled() with empty handle");
1752
1753   RenderTask task;
1754   try
1755   {
1756     bool x = task.GetClearEnabled();
1757     (void) x;
1758   }
1759   catch (Dali::DaliException& e)
1760   {
1761     DALI_TEST_PRINT_ASSERT( e );
1762     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
1763   }
1764   END_TEST;
1765 }
1766
1767 int UtcDaliRenderTaskSetCullModeP(void)
1768 {
1769   TestApplication application;
1770
1771   tet_infoline("Testing RenderTask::SetCullMode()");
1772
1773   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1774   RenderTask task = taskList.GetTask( 0u );
1775   DALI_TEST_EQUALS( task.GetCullMode(), true, TEST_LOCATION );
1776
1777   task.SetCullMode( false );
1778
1779   DALI_TEST_EQUALS( task.GetCullMode(), false, TEST_LOCATION );
1780
1781   END_TEST;
1782 }
1783
1784 int UtcDaliRenderTaskSetCullModeN(void)
1785 {
1786   TestApplication application;
1787
1788   tet_infoline("Testing RenderTask::SetCullMode() on empty handle");
1789
1790   RenderTask task;
1791   try
1792   {
1793     task.SetCullMode( false );
1794   }
1795   catch (Dali::DaliException& e)
1796   {
1797     DALI_TEST_PRINT_ASSERT( e );
1798     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
1799   }
1800   END_TEST;
1801 }
1802
1803 int UtcDaliRenderTaskGetCullModeP(void)
1804 {
1805   TestApplication application;
1806
1807   tet_infoline("Testing RenderTask::GetCullMode()");
1808
1809   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1810   RenderTask task = taskList.GetTask( 0u );
1811   DALI_TEST_EQUALS( task.GetCullMode(), true, TEST_LOCATION );
1812   END_TEST;
1813 }
1814
1815 int UtcDaliRenderTaskGetCullModeN(void)
1816 {
1817   TestApplication application;
1818
1819   tet_infoline("Testing RenderTask::GetCullMode() with empty handle");
1820
1821   RenderTask task;
1822   try
1823   {
1824     bool x = task.GetCullMode();
1825     (void) x;
1826   }
1827   catch (Dali::DaliException& e)
1828   {
1829     DALI_TEST_PRINT_ASSERT( e );
1830     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
1831   }
1832   END_TEST;
1833 }
1834
1835
1836 int UtcDaliRenderTaskSetRefreshRate(void)
1837 {
1838   TestApplication application;
1839
1840   tet_infoline("Testing RenderTask::SetRefreshRate()");
1841
1842   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1843
1844   // By default tasks will be processed every frame
1845   RenderTask task = taskList.GetTask( 0u );
1846   DALI_TEST_CHECK( RenderTask::REFRESH_ALWAYS == task.GetRefreshRate() );
1847
1848   task.SetRefreshRate( 2u ); // every-other frame
1849   DALI_TEST_CHECK( 2u == task.GetRefreshRate() );
1850
1851   task.SetRefreshRate( RenderTask::REFRESH_ALWAYS );
1852   DALI_TEST_CHECK( RenderTask::REFRESH_ALWAYS == task.GetRefreshRate() );
1853   END_TEST;
1854 }
1855
1856 int UtcDaliRenderTaskGetRefreshRate(void)
1857 {
1858   TestApplication application;
1859
1860   tet_infoline("Testing RenderTask::GetRefreshRate()");
1861
1862   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1863
1864   // By default tasks will be processed every frame
1865   RenderTask task = taskList.GetTask( 0u );
1866   DALI_TEST_CHECK( RenderTask::REFRESH_ALWAYS == task.GetRefreshRate() );
1867
1868   RenderTask newTask = taskList.CreateTask();
1869   DALI_TEST_CHECK( RenderTask::REFRESH_ALWAYS == newTask.GetRefreshRate() );
1870   END_TEST;
1871 }
1872
1873 int UtcDaliRenderTaskSignalFinished(void)
1874 {
1875   TestApplication application;
1876
1877   tet_infoline("Testing RenderTask::SignalFinished()");
1878
1879   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1880   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
1881
1882   CameraActor offscreenCameraActor = CameraActor::New();
1883
1884   Stage::GetCurrent().Add( offscreenCameraActor );
1885
1886   Texture image = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, 10, 10 );
1887   Actor rootActor = CreateRenderableActor( image );
1888   rootActor.SetProperty( Actor::Property::SIZE, Vector2( 10.0f, 10.0f ) );
1889   Stage::GetCurrent().Add( rootActor );
1890
1891   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1892   NativeImageInterfacePtr testNativeImagePtr = TestNativeImage::New(10, 10);
1893   FrameBufferImage frameBufferImage = FrameBufferImage::New( *testNativeImagePtr.Get() );
1894
1895   RenderTask newTask = taskList.CreateTask();
1896   newTask.SetCameraActor( offscreenCameraActor );
1897   newTask.SetSourceActor( rootActor );
1898   newTask.SetInputEnabled( false );
1899   newTask.SetClearColor( Vector4( 0.f, 0.f, 0.f, 0.f ) );
1900   newTask.SetClearEnabled( true );
1901   newTask.SetExclusive( true );
1902   newTask.SetRefreshRate( RenderTask::REFRESH_ONCE );
1903   newTask.SetTargetFrameBuffer( frameBufferImage );
1904   newTask.SetProperty( RenderTask::Property::REQUIRES_SYNC, true );
1905
1906   bool finished = false;
1907   RenderTaskFinished renderTaskFinished( finished );
1908   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1909
1910   // Flush the queue and render.
1911   application.SendNotification();
1912
1913   // 1 render to process render task, then wait for sync before finished msg is sent
1914   // from update to the event thread.
1915
1916   application.Render();
1917   application.SendNotification();
1918   DALI_TEST_CHECK( !finished );
1919
1920   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
1921   DALI_TEST_CHECK( lastSyncObj != NULL );
1922
1923   application.Render();
1924   DALI_TEST_EQUALS( (Integration::KeepUpdating::Reasons)(application.GetUpdateStatus() & Integration::KeepUpdating::RENDER_TASK_SYNC), Integration::KeepUpdating::RENDER_TASK_SYNC, TEST_LOCATION );
1925   application.SendNotification();
1926   DALI_TEST_CHECK( !finished );
1927
1928   application.Render();
1929   DALI_TEST_EQUALS( (Integration::KeepUpdating::Reasons)(application.GetUpdateStatus() & Integration::KeepUpdating::RENDER_TASK_SYNC), Integration::KeepUpdating::RENDER_TASK_SYNC, TEST_LOCATION );
1930   application.SendNotification();
1931   DALI_TEST_CHECK( ! finished );
1932
1933   sync.SetObjectSynced( lastSyncObj, true );
1934
1935   application.Render();
1936   application.SendNotification();
1937   DALI_TEST_CHECK( !finished );
1938
1939   application.Render();
1940   application.SendNotification();
1941   DALI_TEST_CHECK( finished );
1942
1943   DALI_TEST_EQUALS( application.GetUpdateStatus(), 0, TEST_LOCATION );
1944   END_TEST;
1945 }
1946
1947
1948 int UtcDaliRenderTaskContinuous01(void)
1949 {
1950   TestApplication application;
1951
1952   tet_infoline("Testing RenderTask Render Continuous using loading image\nPRE: render task not ready (source actor not staged)\nPOST:continuous renders, no Finished signal");
1953
1954   // SETUP AN OFFSCREEN RENDER TASK
1955   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1956   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1957   drawTrace.Enable(true);
1958
1959   Actor rootActor = Actor::New();
1960   Stage::GetCurrent().Add( rootActor );
1961
1962   CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
1963   Stage::GetCurrent().Add( offscreenCameraActor );
1964
1965   Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
1966
1967   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1968   bool finished = false;
1969   RenderTaskFinished renderTaskFinished( finished );
1970   application.SendNotification();
1971
1972   // START PROCESS/RENDER                     Input,    Expected  Input, Expected, KeepUpdating
1973   DALI_TEST_CHECK( UpdateRender(application,  drawTrace, false,   finished, false, false, __LINE__ ) );
1974   application.GetPlatform().ClearReadyResources();
1975
1976   // ADD SOURCE ACTOR TO STAGE - expect continuous renders to start, no finished signal
1977   Stage::GetCurrent().Add(secondRootActor);
1978   application.SendNotification();
1979
1980   // CONTINUE PROCESS/RENDER                  Input,    Expected  Input,    Expected
1981   DALI_TEST_CHECK( UpdateRender(application,  drawTrace, true,    finished, false, false, __LINE__ ) );
1982   END_TEST;
1983 }
1984
1985
1986 int UtcDaliRenderTaskContinuous02(void)
1987 {
1988   TestApplication application;
1989
1990   tet_infoline("Testing RenderTask Render Continuous using loading image\nPRE: render task not ready (source actor not visible)\nPOST:continuous renders, no Finished signal");
1991
1992   // SETUP AN OFFSCREEN RENDER TASK
1993   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1994   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1995   drawTrace.Enable(true);
1996
1997   Actor rootActor = Actor::New();
1998   Stage::GetCurrent().Add( rootActor );
1999
2000   CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
2001   Stage::GetCurrent().Add( offscreenCameraActor );
2002
2003   Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
2004   Stage::GetCurrent().Add(secondRootActor);
2005   secondRootActor.SetProperty( Actor::Property::VISIBLE,false);
2006
2007   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
2008   bool finished = false;
2009   RenderTaskFinished renderTaskFinished( finished );
2010   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2011   application.SendNotification();
2012
2013   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected, KeepUpdating
2014   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, false, __LINE__ ) );
2015   application.GetPlatform().ClearReadyResources();
2016
2017   // MAKE SOURCE ACTOR VISIBLE - expect continuous renders to start, no finished signal
2018   secondRootActor.SetProperty( Actor::Property::VISIBLE,true);
2019   application.SendNotification();
2020
2021   // CONTINUE PROCESS/RENDER                 Input,    Expected  Input,    Expected
2022   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false, __LINE__ ) );
2023   END_TEST;
2024 }
2025
2026 int UtcDaliRenderTaskContinuous03(void)
2027 {
2028   TestApplication application;
2029
2030   tet_infoline("Testing RenderTask Render Continuous using loading image\nPRE: render task not ready (camera actor not staged)\nPOST:continuous renders, no Finished signal");
2031
2032   // SETUP AN OFFSCREEN RENDER TASK
2033   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2034   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2035   drawTrace.Enable(true);
2036
2037   Actor rootActor = Actor::New();
2038   Stage::GetCurrent().Add( rootActor );
2039
2040   CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
2041   Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
2042   Stage::GetCurrent().Add(secondRootActor);
2043
2044   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
2045   bool finished = false;
2046   RenderTaskFinished renderTaskFinished( finished );
2047   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2048   application.SendNotification();
2049
2050   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2051   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, false, __LINE__ ) );
2052   application.GetPlatform().ClearReadyResources();
2053
2054   // ADD CAMERA ACTOR TO STAGE - expect continuous renders to start, no finished signal
2055   Stage::GetCurrent().Add( offscreenCameraActor );
2056   application.SendNotification();
2057
2058   // CONTINUE PROCESS/RENDER                 Input,    Expected  Input,    Expected
2059   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false, __LINE__ ) );
2060   END_TEST;
2061 }
2062
2063
2064 int UtcDaliRenderTaskContinuous04(void)
2065 {
2066   TestApplication application;
2067
2068   tet_infoline("Testing RenderTask Render Continuous using loaded image");
2069
2070   // SETUP AN OFFSCREEN RENDER TASK
2071   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2072   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2073   drawTrace.Enable(true);
2074
2075   Actor rootActor = Actor::New();
2076   Stage::GetCurrent().Add( rootActor );
2077
2078   CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
2079   Stage::GetCurrent().Add( offscreenCameraActor );
2080   Actor secondRootActor = CreateRenderableActorFailed(application, "aFile.jpg");
2081   Stage::GetCurrent().Add(secondRootActor);
2082
2083   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
2084   bool finished = false;
2085   RenderTaskFinished renderTaskFinished( finished );
2086   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2087   application.SendNotification();
2088
2089   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2090   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,   finished, false, false, __LINE__ ) );
2091   END_TEST;
2092 }
2093
2094 int UtcDaliRenderTaskOnce01(void)
2095 {
2096   TestApplication application;
2097
2098   tet_infoline("Testing RenderTask Render Once GlSync, using loaded image");
2099
2100   // SETUP AN OFFSCREEN RENDER TASK
2101   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2102   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
2103   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2104   drawTrace.Enable(true);
2105
2106   Actor rootActor = Actor::New();
2107   Stage::GetCurrent().Add( rootActor );
2108
2109   CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
2110   Stage::GetCurrent().Add( offscreenCameraActor );
2111   Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
2112
2113   Stage::GetCurrent().Add(secondRootActor);
2114
2115   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, true);
2116   bool finished = false;
2117   RenderTaskFinished renderTaskFinished( finished );
2118   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2119   application.SendNotification();
2120
2121   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,   finished, false, true, __LINE__  ) );
2122
2123   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
2124   DALI_TEST_CHECK( lastSyncObj != NULL );
2125   sync.SetObjectSynced( lastSyncObj, true );
2126
2127   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true, __LINE__  ) );
2128   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false, __LINE__  ) );
2129   END_TEST;
2130 }
2131
2132 int UtcDaliRenderTaskOnce02(void)
2133 {
2134   TestApplication application;
2135
2136   tet_infoline("Testing RenderTask Render Once GlSync, using Mesh which accesses texture through sampler with loaded image.\n");
2137
2138   // SETUP AN OFFSCREEN RENDER TASK
2139   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2140   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
2141   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2142   drawTrace.Enable(true);
2143
2144   Actor rootActor = Actor::New();
2145   Stage::GetCurrent().Add( rootActor );
2146
2147   CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
2148   Stage::GetCurrent().Add( offscreenCameraActor );
2149
2150   Shader shader = CreateShader();
2151   Image image = CreateResourceImage(application, "aFile.jpg");
2152   TextureSet textureSet = CreateTextureSet( image );
2153
2154   Geometry geometry = CreateQuadGeometry();
2155   Renderer renderer = Renderer::New(geometry, shader);
2156   renderer.SetTextures( textureSet );
2157   Actor secondRootActor = Actor::New();
2158   secondRootActor.AddRenderer(renderer);
2159   secondRootActor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
2160   Stage::GetCurrent().Add(secondRootActor);
2161
2162   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, true);
2163   bool finished = false;
2164   RenderTaskFinished renderTaskFinished( finished );
2165   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2166   application.SendNotification();
2167
2168   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,   finished, false, true, __LINE__  ) );
2169
2170   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
2171   DALI_TEST_CHECK( lastSyncObj != NULL );
2172   sync.SetObjectSynced( lastSyncObj, true );
2173
2174   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true, __LINE__  ) );
2175   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false, __LINE__  ) );
2176
2177    END_TEST;
2178 }
2179
2180 int UtcDaliRenderTaskOnce03(void)
2181 {
2182   TestApplication application;
2183
2184   tet_infoline("Testing RenderTask Render Once GlSync, using loaded image. Switch from render always after ready to render once\n");
2185
2186   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2187   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2188   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
2189   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2190   drawTrace.Enable(true);
2191
2192   Actor rootActor = Actor::New();
2193   Stage::GetCurrent().Add( rootActor );
2194
2195   CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
2196   Stage::GetCurrent().Add( offscreenCameraActor );
2197   Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
2198   Stage::GetCurrent().Add(secondRootActor);
2199
2200   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
2201   bool finished = false;
2202   RenderTaskFinished renderTaskFinished( finished );
2203   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2204   application.SendNotification();
2205
2206   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false, __LINE__ ) );
2207
2208   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2209   application.SendNotification();
2210
2211   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,   finished, false, true, __LINE__  ) );
2212
2213   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
2214   DALI_TEST_CHECK( lastSyncObj != NULL );
2215   sync.SetObjectSynced( lastSyncObj, true );
2216
2217   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true, __LINE__  ) );
2218   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false, __LINE__  ) );
2219
2220   END_TEST;
2221 }
2222
2223
2224 int UtcDaliRenderTaskOnce04(void)
2225 {
2226   TestApplication application;
2227   tet_infoline("Testing RenderTask Render Once GlSync, using Mesh which accesses texture through sampler with loaded image.\n"
2228                "Switch from render always after ready to render once\n"
2229               );
2230
2231   // SETUP AN OFFSCREEN RENDER TASK
2232   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2233   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
2234   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2235   drawTrace.Enable(true);
2236
2237   Actor rootActor = Actor::New();
2238   Stage::GetCurrent().Add( rootActor );
2239
2240   CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
2241   Stage::GetCurrent().Add( offscreenCameraActor );
2242
2243   Shader shader = CreateShader();
2244   Image image = CreateResourceImage(application, "aFile.jpg");
2245   TextureSet textureSet = CreateTextureSet( image );
2246
2247   Geometry geometry = CreateQuadGeometry();
2248   Renderer renderer = Renderer::New(geometry, shader);
2249   renderer.SetTextures( textureSet );
2250   Actor secondRootActor = Actor::New();
2251   secondRootActor.AddRenderer(renderer);
2252   secondRootActor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
2253   Stage::GetCurrent().Add(secondRootActor);
2254
2255   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
2256   bool finished = false;
2257   RenderTaskFinished renderTaskFinished( finished );
2258   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2259   application.SendNotification();
2260
2261   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false, __LINE__ ) );
2262
2263   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2264   application.SendNotification();
2265
2266   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,   finished, false, true, __LINE__  ) );
2267
2268   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
2269   DALI_TEST_CHECK( lastSyncObj != NULL );
2270   sync.SetObjectSynced( lastSyncObj, true );
2271
2272   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true, __LINE__  ) );
2273   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false, __LINE__  ) );
2274
2275   END_TEST;
2276 }
2277
2278 int UtcDaliRenderTaskOnceNoSync01(void)
2279 {
2280   TestApplication application;
2281
2282   tet_infoline("Testing RenderTask Render Once, \nPRE: Resources ready\nPOST: Finished signal sent once only");
2283
2284   // SETUP AN OFFSCREEN RENDER TASK
2285   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2286   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2287   drawTrace.Enable(true);
2288
2289   Actor rootActor = Actor::New();
2290   Stage::GetCurrent().Add( rootActor );
2291
2292   CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
2293   Stage::GetCurrent().Add( offscreenCameraActor );
2294   Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
2295   Stage::GetCurrent().Add(secondRootActor);
2296
2297   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, false);
2298   bool finished = false;
2299   RenderTaskFinished renderTaskFinished( finished );
2300   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2301   application.SendNotification();
2302
2303   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true, __LINE__ ) );
2304   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false, __LINE__ ) );
2305   END_TEST;
2306 }
2307
2308 int UtcDaliRenderTaskOnceNoSync02(void)
2309 {
2310   TestApplication application;
2311
2312   tet_infoline("Testing RenderTask Render Once, using Mesh which accesses texture through sampler with loaded image.\n"
2313                "PRE: Resources ready\nPOST: Finished signal sent once only");
2314   // SETUP AN OFFSCREEN RENDER TASK
2315   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2316   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2317   drawTrace.Enable(true);
2318
2319   Actor rootActor = Actor::New();
2320   Stage::GetCurrent().Add( rootActor );
2321
2322   CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
2323   Stage::GetCurrent().Add( offscreenCameraActor );
2324
2325   Shader shader = CreateShader();
2326   Image image = CreateResourceImage(application, "aFile.jpg");
2327   TextureSet textureSet = CreateTextureSet( image );
2328
2329   Geometry geometry = CreateQuadGeometry();
2330   Renderer renderer = Renderer::New(geometry, shader);
2331   renderer.SetTextures( textureSet );
2332   Actor secondRootActor = Actor::New();
2333   secondRootActor.AddRenderer(renderer);
2334   secondRootActor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
2335   Stage::GetCurrent().Add(secondRootActor);
2336
2337   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, false);
2338   bool finished = false;
2339   RenderTaskFinished renderTaskFinished( finished );
2340   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2341   application.SendNotification();
2342
2343   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true, __LINE__ ) );
2344   application.GetPlatform().ClearReadyResources();
2345   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false, __LINE__ ) );
2346
2347   END_TEST;
2348 }
2349
2350 int UtcDaliRenderTaskOnceNoSync03(void)
2351 {
2352   TestApplication application;
2353
2354   tet_infoline("Testing RenderTask Render Once, using loaded image. Switch from render always after ready to render once\n"
2355                "PRE: Render task ready, Image loaded\n"
2356                "POST: Finished signal sent only once");
2357
2358   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2359   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2360   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2361   drawTrace.Enable(true);
2362
2363   Actor rootActor = Actor::New();
2364   Stage::GetCurrent().Add( rootActor );
2365
2366   CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
2367   Stage::GetCurrent().Add( offscreenCameraActor );
2368   Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
2369   Stage::GetCurrent().Add(secondRootActor);
2370
2371   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
2372   bool finished = false;
2373   RenderTaskFinished renderTaskFinished( finished );
2374   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2375   application.SendNotification();
2376
2377   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false, __LINE__ ) );
2378
2379   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2380   application.SendNotification(); //         Input,    Expected  Input,    Expected
2381   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true, __LINE__ ) );
2382   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false, __LINE__ ) );
2383   END_TEST;
2384 }
2385
2386 int UtcDaliRenderTaskOnceNoSync04(void)
2387 {
2388   TestApplication application;
2389
2390   tet_infoline("Testing RenderTask Render Once, using Mesh which accesses texture through sampler with loading image.\n"
2391                "Switch from render always after ready to render once\n"
2392                "PRE: Render task ready, Image not loaded\n"
2393                "POST: Finished signal sent only once");
2394
2395   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2396   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2397   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2398   drawTrace.Enable(true);
2399
2400   Actor rootActor = Actor::New();
2401   Stage::GetCurrent().Add( rootActor );
2402
2403   CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
2404   Stage::GetCurrent().Add( offscreenCameraActor );
2405
2406   Shader shader = CreateShader();
2407   Image image = CreateResourceImage(application, "aFile.jpg");
2408   TextureSet textureSet = CreateTextureSet( image );
2409
2410   Geometry geometry = CreateQuadGeometry();
2411   Renderer renderer = Renderer::New(geometry, shader);
2412   renderer.SetTextures( textureSet );
2413   Actor secondRootActor = Actor::New();
2414   secondRootActor.AddRenderer(renderer);
2415   secondRootActor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
2416   Stage::GetCurrent().Add(secondRootActor);
2417
2418
2419   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
2420   bool finished = false;
2421   RenderTaskFinished renderTaskFinished( finished );
2422   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2423   application.SendNotification();
2424
2425   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false, __LINE__ ) );
2426   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
2427   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
2428   DALI_TEST_CHECK( lastSyncObj == NULL );
2429
2430   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2431   application.SendNotification(); //         Input,    Expected  Input,    Expected
2432   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true, __LINE__ ) );
2433   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false, __LINE__ ) );
2434
2435   lastSyncObj = sync.GetLastSyncObject();
2436   DALI_TEST_CHECK( lastSyncObj == NULL );
2437
2438   END_TEST;
2439 }
2440
2441 int UtcDaliRenderTaskOnceNoSync05(void)
2442 {
2443   TestApplication application;
2444
2445   tet_infoline("Testing RenderTask Render Once\n"
2446                "SetRefreshRate(ONCE), resource load failed, completes render task.\n"
2447                "PRE: resources failed to load\n"
2448                "POST: No finished signal sent.");
2449
2450   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2451   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2452   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2453   drawTrace.Enable(true);
2454
2455   Actor rootActor = Actor::New();
2456   Stage::GetCurrent().Add( rootActor );
2457
2458   CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
2459   Stage::GetCurrent().Add( offscreenCameraActor );
2460   Actor secondRootActor = CreateRenderableActorFailed(application, "aFile.jpg");
2461   Stage::GetCurrent().Add(secondRootActor);
2462
2463   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
2464   bool finished = false;
2465   RenderTaskFinished renderTaskFinished( finished );
2466   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2467   application.SendNotification();
2468
2469   // START PROCESS/RENDER                    Input,     Expected  Input,    Expected
2470   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false, __LINE__ ) );
2471
2472   // CHANGE TO RENDER ONCE,
2473   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2474   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false, __LINE__ ) );
2475
2476   END_TEST;
2477 }
2478
2479
2480
2481 int UtcDaliRenderTaskOnceChain01(void)
2482 {
2483   TestApplication application;
2484
2485   tet_infoline("Testing RenderTask Render Once Chained render tasks\n"
2486                "SetRefreshRate(ONCE), resource load completes, both render tasks render.\n"
2487                "PRE: resources ready\n"
2488                "POST: 2 finished signals sent.");
2489
2490   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2491   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2492   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2493   drawTrace.Enable(true);
2494
2495   Actor defaultRootActor = Actor::New(); // Root for default RT
2496   Stage::GetCurrent().Add( defaultRootActor );
2497
2498   CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
2499   Stage::GetCurrent().Add( offscreenCameraActor );
2500   Actor firstRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
2501   Stage::GetCurrent().Add(firstRootActor);
2502
2503   // first render task
2504   RenderTask firstTask = CreateRenderTask(application, offscreenCameraActor, defaultRootActor, firstRootActor, RenderTask::REFRESH_ONCE, false);
2505   bool firstFinished = false;
2506   RenderTaskFinished renderTask1Finished( firstFinished );
2507   firstTask.FinishedSignal().Connect( &application, renderTask1Finished );
2508
2509   // Second render task
2510   FrameBufferImage fbo = firstTask.GetTargetFrameBuffer();
2511   Actor secondRootActor = CreateRenderableActor( fbo );
2512   Stage::GetCurrent().Add(secondRootActor);
2513   RenderTask secondTask = CreateRenderTask(application, offscreenCameraActor, defaultRootActor, secondRootActor, RenderTask::REFRESH_ONCE, false);
2514   bool secondFinished = false;
2515   RenderTaskFinished renderTask2Finished( secondFinished );
2516   secondTask.FinishedSignal().Connect( &application, renderTask2Finished );
2517
2518   application.SendNotification();
2519
2520   //Both render tasks are executed.
2521   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,  firstFinished, false, true, __LINE__ ) );
2522   DALI_TEST_CHECK( firstFinished == false );
2523   DALI_TEST_CHECK( secondFinished == false );
2524
2525   //Nothing else to render and both render task should have finished now
2526   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,  firstFinished, true, false, __LINE__ ) );
2527   DALI_TEST_CHECK( firstFinished == true );
2528   DALI_TEST_CHECK( secondFinished == true );
2529
2530   END_TEST;
2531 }
2532
2533 int UtcDaliRenderTaskProperties(void)
2534 {
2535   TestApplication application;
2536
2537   RenderTask task = Stage::GetCurrent().GetRenderTaskList().CreateTask();
2538
2539   Property::IndexContainer indices;
2540   task.GetPropertyIndices( indices );
2541   DALI_TEST_CHECK( indices.Size() );
2542   DALI_TEST_EQUALS( indices.Size(), task.GetPropertyCount(), TEST_LOCATION );
2543   END_TEST;
2544 }
2545
2546 int UtcDaliRenderTaskFinishInvisibleSourceActor(void)
2547 {
2548   TestApplication application;
2549
2550   tet_infoline("Testing RenderTask::FinishInvisibleSourceActor()");
2551
2552   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2553   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
2554
2555   CameraActor offscreenCameraActor = CameraActor::New();
2556
2557   Stage::GetCurrent().Add( offscreenCameraActor );
2558
2559   Texture image = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, 10, 10 );
2560   Actor rootActor = CreateRenderableActor( image );
2561   rootActor.SetProperty( Actor::Property::SIZE, Vector2( 10.0f, 10.0f ) );
2562   rootActor.SetProperty( Actor::Property::VISIBLE,false);
2563   Stage::GetCurrent().Add( rootActor );
2564
2565   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
2566   NativeImageInterfacePtr testNativeImagePtr = TestNativeImage::New(10, 10);
2567   FrameBufferImage frameBufferImage = FrameBufferImage::New( *testNativeImagePtr.Get() );
2568
2569   // Flush all outstanding messages
2570   application.SendNotification();
2571   application.Render();
2572
2573   RenderTask newTask = taskList.CreateTask();
2574   newTask.SetCameraActor( offscreenCameraActor );
2575   newTask.SetSourceActor( rootActor );
2576   newTask.SetInputEnabled( false );
2577   newTask.SetClearColor( Vector4( 0.f, 0.f, 0.f, 0.f ) );
2578   newTask.SetClearEnabled( true );
2579   newTask.SetExclusive( true );
2580   newTask.SetRefreshRate( RenderTask::REFRESH_ONCE );
2581   newTask.SetTargetFrameBuffer( frameBufferImage );
2582   newTask.SetProperty( RenderTask::Property::REQUIRES_SYNC, true );
2583
2584   // Framebuffer doesn't actually get created until Connected, i.e. by previous line
2585
2586   bool finished = false;
2587   RenderTaskFinished renderTaskFinished( finished );
2588   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2589
2590   // Flush the queue and render.
2591   application.SendNotification();
2592
2593   // 1 render to process render task, then wait for sync before finished msg is sent
2594   // from update to the event thread.
2595
2596   application.Render();
2597   application.SendNotification();
2598   DALI_TEST_CHECK( !finished );
2599
2600   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
2601   DALI_TEST_CHECK( lastSyncObj != NULL );
2602
2603   application.Render();
2604   DALI_TEST_EQUALS( (Integration::KeepUpdating::Reasons)(application.GetUpdateStatus() & Integration::KeepUpdating::RENDER_TASK_SYNC), Integration::KeepUpdating::RENDER_TASK_SYNC, TEST_LOCATION );
2605   application.SendNotification();
2606   DALI_TEST_CHECK( !finished );
2607
2608   application.Render();
2609   DALI_TEST_EQUALS( (Integration::KeepUpdating::Reasons)(application.GetUpdateStatus() & Integration::KeepUpdating::RENDER_TASK_SYNC), Integration::KeepUpdating::RENDER_TASK_SYNC, TEST_LOCATION );
2610   application.SendNotification();
2611   DALI_TEST_CHECK( ! finished );
2612
2613   sync.SetObjectSynced( lastSyncObj, true );
2614
2615   application.Render();
2616   application.SendNotification();
2617   DALI_TEST_CHECK( !finished );
2618
2619   application.Render();
2620   application.SendNotification();
2621   DALI_TEST_CHECK( finished );
2622   finished = false;
2623
2624   application.Render(); // Double check no more finished signal
2625   application.SendNotification();
2626   DALI_TEST_CHECK( ! finished );
2627
2628   END_TEST;
2629 }
2630
2631 int UtcDaliRenderTaskFinishMissingImage(void)
2632 {
2633   TestApplication application;
2634
2635   // Previously we had bugs where not having a resource ID would cause render-tasks to wait forever
2636   tet_infoline("Testing RenderTask::SignalFinished() when an Actor has no Image set");
2637
2638   Stage stage = Stage::GetCurrent();
2639
2640   Texture image = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, 10, 10 );
2641   Actor rootActor = CreateRenderableActor( image );
2642   rootActor.SetProperty( Actor::Property::SIZE, Vector2( 10.0f, 10.0f ) );
2643   stage.Add( rootActor );
2644
2645   Actor actorWithMissingImage = CreateRenderableActor( Image() );
2646   actorWithMissingImage.SetProperty( Actor::Property::SIZE, Vector2( 10.0f, 10.0f ) );
2647   stage.Add( actorWithMissingImage );
2648
2649   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
2650   RenderTask newTask = taskList.CreateTask();
2651   newTask.SetInputEnabled( false );
2652   newTask.SetClearColor( Vector4( 0.f, 0.f, 0.f, 0.f ) );
2653   newTask.SetClearEnabled( true );
2654   newTask.SetExclusive( true );
2655   newTask.SetRefreshRate( RenderTask::REFRESH_ONCE );
2656
2657   bool finished = false;
2658   RenderTaskFinished renderTaskFinished( finished );
2659   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2660
2661   // 1 render to process render task, then 1 before finished msg is sent from update to the event thread.
2662   application.SendNotification();
2663   application.Render();
2664   application.Render();
2665
2666   application.SendNotification();
2667   DALI_TEST_CHECK( finished );
2668
2669   END_TEST;
2670 }
2671
2672 int UtcDaliRenderTaskWorldToViewport(void)
2673 {
2674   TestApplication application( 400u, 400u ); // square surface
2675
2676   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
2677
2678   Actor actor = Actor::New();
2679   actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
2680   actor.SetProperty( Actor::Property::POSITION, Vector3(0.0, 0.0, 0.0) );
2681
2682   actor.SetProperty( Actor::Property::PARENT_ORIGIN, Vector3(0.5, 0.5, 0.5) );
2683   actor.SetProperty( Actor::Property::ANCHOR_POINT, Vector3(0.5, 0.5, 0.5) );
2684
2685   Stage::GetCurrent().Add(actor);
2686
2687   application.SendNotification();
2688   application.Render();
2689   application.SendNotification();
2690
2691   RenderTask task = taskList.GetTask( 0u );
2692
2693   CameraActor camera = task.GetCameraActor();
2694
2695   Vector2 screenSize = task.GetCurrentViewportSize();
2696
2697   float screenX = 0.0;
2698   float screenY = 0.0;
2699
2700   bool ok = task.WorldToViewport(actor.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), screenX, screenY);
2701   DALI_TEST_CHECK(ok == true);
2702
2703   DALI_TEST_EQUALS(screenX, screenSize.x/2, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
2704   DALI_TEST_EQUALS(screenY, screenSize.y/2, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
2705
2706   Actor actor2 = Actor::New();
2707   float actor2Size = 100.f;
2708   actor2.SetProperty( Actor::Property::SIZE, Vector2( actor2Size, actor2Size ) );
2709   actor2.SetProperty( Actor::Property::POSITION, Vector3(0.0, 0.0, 0.0) );
2710   actor2.SetProperty( Actor::Property::PARENT_ORIGIN, Vector3(0.5, 0.5, 0.0) );
2711   actor2.SetProperty( Actor::Property::ANCHOR_POINT, Vector3(0.5, 0.5, 0.0) );
2712   Stage::GetCurrent().Add( actor2 );
2713   actor2.Add(actor);
2714   actor.SetProperty( Actor::Property::PARENT_ORIGIN, Vector3(0,0,0) );
2715
2716   application.SendNotification();
2717   application.Render();
2718   application.SendNotification();
2719
2720   ok = task.WorldToViewport(actor.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), screenX, screenY);
2721   DALI_TEST_CHECK(ok == true);
2722
2723   DALI_TEST_EQUALS(screenX, screenSize.x/2 - actor2Size/2, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
2724   DALI_TEST_EQUALS(screenY, screenSize.y/2 - actor2Size/2, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
2725
2726   END_TEST;
2727 }
2728
2729
2730 int UtcDaliRenderTaskViewportToLocal(void)
2731 {
2732   TestApplication application;
2733   Actor actor = Actor::New();
2734   actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
2735   actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
2736   actor.SetProperty( Actor::Property::POSITION, Vector2(10.0f, 10.0f));
2737   Stage::GetCurrent().Add(actor);
2738
2739   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
2740   RenderTask task = taskList.GetTask( 0u );
2741
2742   // flush the queue and render once
2743   application.SendNotification();
2744   application.Render();
2745   application.SendNotification();
2746   application.Render();
2747
2748   float localX;
2749   float localY;
2750
2751   float rtLocalX;
2752   float rtLocalY;
2753
2754   float screenX = 50.0f;
2755   float screenY = 50.0f;
2756
2757   DALI_TEST_CHECK( actor.ScreenToLocal(localX, localY, screenX, screenY) );
2758
2759   DALI_TEST_CHECK( task.ViewportToLocal(actor, screenX, screenY, rtLocalX, rtLocalY ) );
2760
2761   DALI_TEST_EQUALS(localX, rtLocalX, 0.01f, TEST_LOCATION);
2762   DALI_TEST_EQUALS(localY, rtLocalY, 0.01f, TEST_LOCATION);
2763
2764   END_TEST;
2765
2766 }
2767
2768 int UtcDaliRenderTaskOffscreenViewportToLocal(void)
2769 {
2770   TestApplication application;
2771   Actor actor = Actor::New();
2772   actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
2773   actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
2774   actor.SetProperty( Actor::Property::POSITION, Vector2( 10.0f, 10.0f ));
2775   Stage::GetCurrent().Add( actor );
2776
2777   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
2778   RenderTask task = taskList.CreateTask();
2779
2780   FrameBufferImage newFrameBuffer = FrameBufferImage::New( 10, 10 );
2781   task.SetTargetFrameBuffer( newFrameBuffer );
2782   task.SetSourceActor( actor );
2783   task.SetScreenToFrameBufferMappingActor( actor );
2784
2785   CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
2786   Stage::GetCurrent().Add( offscreenCameraActor );
2787   task.SetCameraActor( offscreenCameraActor );
2788
2789   // flush the queue and render once
2790   application.SendNotification();
2791   application.Render();
2792   application.SendNotification();
2793   application.Render();
2794
2795   float localX;
2796   float localY;
2797
2798   float rtLocalX;
2799   float rtLocalY;
2800
2801   float screenX = 50.0f;
2802   float screenY = 50.0f;
2803
2804   DALI_TEST_CHECK( actor.ScreenToLocal(localX, localY, screenX, screenY) );
2805
2806   DALI_TEST_CHECK( task.ViewportToLocal(actor, screenX, screenY, rtLocalX, rtLocalY ) );
2807
2808   DALI_TEST_EQUALS(localX, rtLocalX, 0.01f, TEST_LOCATION);
2809   DALI_TEST_EQUALS(localY, rtLocalY, 0.01f, TEST_LOCATION);
2810
2811   END_TEST;
2812 }
2813
2814 int UtcDaliRenderTaskRequiresSync(void)
2815 {
2816   TestApplication application;
2817   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
2818
2819   RenderTask newTask = taskList.CreateTask();
2820   newTask.SetProperty( RenderTask::Property::REQUIRES_SYNC, false );
2821
2822   DALI_TEST_EQUALS( newTask.GetProperty< bool >( RenderTask::Property::REQUIRES_SYNC ), false, TEST_LOCATION );
2823   DALI_TEST_EQUALS( newTask.GetCurrentProperty< bool >( RenderTask::Property::REQUIRES_SYNC ), false, TEST_LOCATION );
2824
2825   newTask.SetProperty( RenderTask::Property::REQUIRES_SYNC, true );
2826
2827   DALI_TEST_EQUALS( newTask.GetProperty< bool >( RenderTask::Property::REQUIRES_SYNC ), true, TEST_LOCATION );
2828   DALI_TEST_EQUALS( newTask.GetCurrentProperty< bool >( RenderTask::Property::REQUIRES_SYNC ), true, TEST_LOCATION );
2829
2830   END_TEST;
2831 }
2832
2833 int UtcDaliRenderTaskSetClearEnabled(void)
2834 {
2835   TestApplication application;
2836
2837   tet_infoline("UtcDaliRenderTaskSetClearEnabled");
2838
2839   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2840   TestGlAbstraction& gl = application.GetGlAbstraction();
2841
2842   Actor renderableActor = CreateRenderableActorSuccess( application, "aFile.jpg" );
2843   Stage::GetCurrent().Add( renderableActor );
2844
2845   Actor rootActor = Actor::New();
2846   Stage::GetCurrent().Add( rootActor );
2847
2848   CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
2849   Stage::GetCurrent().Add( offscreenCameraActor );
2850
2851   Actor sourceActor = CreateRenderableActorSuccess( application, "aFile.jpg" );
2852   Stage::GetCurrent().Add( sourceActor );
2853
2854   RenderTask newTask = CreateRenderTask( application, offscreenCameraActor, rootActor, sourceActor, RenderTask::REFRESH_ALWAYS, false );
2855
2856   DALI_TEST_EQUALS( gl.GetClearCountCalled(), 0, TEST_LOCATION );
2857
2858   application.SendNotification();
2859   application.Render();
2860
2861   // glClear should be called twice - default task and the new task.
2862   DALI_TEST_EQUALS( gl.GetClearCountCalled(), 2, TEST_LOCATION );
2863
2864   newTask.SetClearEnabled( false );
2865
2866   application.SendNotification();
2867   application.Render();
2868
2869   // The count should increase by 1 - default task only.
2870   DALI_TEST_EQUALS( gl.GetClearCountCalled(), 3, TEST_LOCATION );
2871
2872   END_TEST;
2873 }