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