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

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