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

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