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

   1 /*
   2  * Copyright (c) 2014 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
  20 #include <stdlib.h>
  21 #include <dali/public-api/dali-core.h>
  22 #include <dali-test-suite-utils.h>
  23 #include <dali/integration-api/debug.h>
  24 #include <test-native-image.h>
  25
  26 #define BOOLSTR(x) ((x)?"T":"F")
  27
  28
  29 using namespace Dali;
  30
  31 void utc_dali_render_task_startup(void)
  32 {
  33   test_return_value = TET_UNDEF;
  34 }
  35
  36 void utc_dali_render_task_cleanup(void)
  37 {
  38   test_return_value = TET_PASS;
  39 }
  40
  41 namespace // unnamed namespace
  42 {
  43
  44 const int RENDER_FRAME_INTERVAL = 16;                           ///< Duration of each frame in ms. (at approx 60FPS)
  45
  46 /*
  47  * Simulate time passed by.
  48  *
  49  * @note this will always process at least 1 frame (1/60 sec)
  50  *
  51  * @param application Test application instance
  52  * @param duration Time to pass in milliseconds.
  53  * @return The actual time passed in milliseconds
  54  */
  55 int Wait(TestApplication& application, int duration = 0)
  56 {
  57   int time = 0;
  58
  59   for(int i = 0; i <= ( duration / RENDER_FRAME_INTERVAL); i++)
  60   {
  61     application.SendNotification();
  62     application.Render(RENDER_FRAME_INTERVAL);
  63     time += RENDER_FRAME_INTERVAL;
  64   }
  65
  66   return time;
  67 }
  68
  69 struct RenderTaskFinished
  70 {
  71   RenderTaskFinished( bool& finished )
  72   : finished( finished )
  73   {
  74   }
  75
  76   void operator()( RenderTask& renderTask )
  77   {
  78     finished = true;
  79   }
  80
  81   bool& finished;
  82 };
  83
  84 struct RenderTaskFinishedRemoveSource
  85 {
  86   RenderTaskFinishedRemoveSource( bool& finished )
  87   : finished( finished ),
  88     finishedOnce(false)
  89   {
  90   }
  91
  92   void operator()( RenderTask& renderTask )
  93   {
  94     DALI_TEST_CHECK(finishedOnce == false);
  95     finished = true;
  96     finishedOnce = true;
  97     Actor srcActor = renderTask.GetSourceActor();
  98     UnparentAndReset(srcActor);
  99   }
 100
 101   bool& finished;
 102   bool finishedOnce;
 103 };
 104
 105 struct RenderTaskFinishedRenderAgain
 106 {
 107   RenderTaskFinishedRenderAgain( bool& finished )
 108   : finished( finished ),
 109     finishedOnce(false)
 110   {
 111   }
 112
 113   void operator()( RenderTask& renderTask )
 114   {
 115     DALI_TEST_CHECK(finishedOnce == false);
 116     finished = true;
 117     finishedOnce = true;
 118     renderTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
 119   }
 120
 121   bool& finished;
 122   bool finishedOnce;
 123 };
 124
 125
 126 bool TestScreenToFrameBufferFunction( Vector2& coordinates )
 127 {
 128   coordinates = coordinates + Vector2( 1, 2 );
 129
 130   return true;
 131 }
 132
 133 ImageActor CreateLoadingImage(TestApplication& application, std::string filename, ResourceImage::LoadPolicy loadPolicy, Image::ReleasePolicy releasePolicy)
 134 {
 135   Image image = ResourceImage::New(filename, loadPolicy, releasePolicy);
 136   DALI_TEST_CHECK( image );
 137   application.SendNotification();
 138   application.Render(16);
 139   DALI_TEST_CHECK( application.GetPlatform().WasCalled(TestPlatformAbstraction::LoadResourceFunc) );
 140   ImageActor actor = ImageActor::New(image);
 141   actor.SetSize( 80, 80 );
 142   application.SendNotification();
 143   application.Render(16);
 144   return actor;
 145 }
 146
 147 void CompleteImageLoad(TestApplication& application, Integration::ResourceId resourceId, Integration::ResourceTypeId requestType)
 148 {
 149   std::vector<GLuint> ids;
 150   ids.push_back( 23 );
 151   application.GetGlAbstraction().SetNextTextureIds( ids );
 152
 153   Integration::Bitmap* bitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::DISCARD );
 154   Integration::ResourcePointer resource(bitmap);
 155   bitmap->GetPackedPixelsProfile()->ReserveBuffer(Pixel::RGBA8888, 80, 80, 80, 80);
 156
 157   application.GetPlatform().SetResourceLoaded(resourceId, requestType, resource);
 158 }
 159
 160 void FailImageLoad(TestApplication& application, Integration::ResourceId resourceId )
 161 {
 162   application.GetPlatform().SetResourceLoadFailed(resourceId, Integration::FailureUnknown);
 163 }
 164
 165 void ReloadImage(TestApplication& application, ResourceImage image)
 166 {
 167   application.GetPlatform().ClearReadyResources();
 168   application.GetPlatform().DiscardRequest();
 169   application.GetPlatform().ResetTrace();
 170   application.GetPlatform().SetClosestImageSize(Vector2(80.0f, 80.0f)); // Ensure reload is called.
 171   image.Reload();
 172 }
 173
 174 RenderTask CreateRenderTask(TestApplication& application,
 175                             CameraActor offscreenCamera,
 176                             Actor rootActor,       // Reset default render task to point at this actor
 177                             Actor secondRootActor, // Source actor
 178                             unsigned int refreshRate,
 179                             bool glSync)
 180 {
 181   // Change main render task to use a different root
 182   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 183   taskList.GetTask(0u).SetSourceActor( rootActor );
 184
 185   FrameBufferImage frameBufferImage;
 186   if( glSync )
 187   {
 188     NativeImageInterfacePtr testNativeImagePtr = TestNativeImage::New(10, 10);
 189     frameBufferImage= FrameBufferImage::New( *(testNativeImagePtr.Get()) );
 190   }
 191   else
 192   {
 193     frameBufferImage = FrameBufferImage::New( 10, 10 );
 194   }
 195
 196   // Don't draw output framebuffer
 197
 198   RenderTask newTask = taskList.CreateTask();
 199   newTask.SetCameraActor( offscreenCamera );
 200   newTask.SetSourceActor( secondRootActor );
 201   newTask.SetInputEnabled( false );
 202   newTask.SetClearColor( Vector4( 0.f, 0.f, 0.f, 0.f ) );
 203   newTask.SetClearEnabled( true );
 204   newTask.SetExclusive( true );
 205   newTask.SetRefreshRate( refreshRate );
 206   newTask.SetTargetFrameBuffer( frameBufferImage );
 207   return newTask;
 208 }
 209
 210 bool UpdateRender(TestApplication& application, TraceCallStack& callStack, bool testDrawn, bool& finishedSig, bool testFinished, bool testKeepUpdating )
 211 {
 212   finishedSig = false;
 213   callStack.Reset();
 214   application.Render(16);
 215   application.SendNotification();
 216
 217   bool sigPassed = false;
 218   if( testFinished )
 219   {
 220     sigPassed = finishedSig;
 221   }
 222   else
 223   {
 224     sigPassed = ! finishedSig;
 225   }
 226
 227   bool drawResult = callStack.FindMethod("DrawElements") || callStack.FindMethod("DrawArrays");
 228
 229   bool drawPassed = false;
 230   if( testDrawn )
 231   {
 232     drawPassed = drawResult;
 233   }
 234   else
 235   {
 236     drawPassed = !drawResult;
 237   }
 238
 239   bool keepUpdating = (application.GetUpdateStatus() != 0);
 240   bool keepUpdatingPassed = false;
 241   if( testKeepUpdating )
 242   {
 243     keepUpdatingPassed = keepUpdating;
 244   }
 245   else
 246   {
 247     keepUpdatingPassed = !keepUpdating;
 248   }
 249
 250   bool result = (sigPassed && drawPassed && keepUpdatingPassed);
 251
 252   tet_printf("UpdateRender: Expected: Draw:%s Signal:%s Keep Updating: %s  Actual: Draw:%s  Signal:%s KeepUpdating: %s  %s\n",
 253              BOOLSTR(testDrawn), BOOLSTR(testFinished), BOOLSTR(testKeepUpdating),
 254              BOOLSTR(drawResult), BOOLSTR(finishedSig), BOOLSTR(keepUpdating),
 255              result ? "Passed":"Failed");
 256
 257   return result;
 258 }
 259
 260 // The functor to be used in the hit-test algorithm to check whether the actor is hittable.
 261 bool IsActorHittableFunction(Actor actor, Dali::HitTestAlgorithm::TraverseType type)
 262 {
 263   bool hittable = false;
 264
 265   switch (type)
 266   {
 267     case Dali::HitTestAlgorithm::CHECK_ACTOR:
 268     {
 269       // Check whether the actor is visible and not fully transparent.
 270       if( actor.IsVisible()
 271        && actor.GetCurrentWorldColor().a > 0.01f) // not FULLY_TRANSPARENT
 272       {
 273
 274           hittable = true;
 275       }
 276       break;
 277     }
 278     case Dali::HitTestAlgorithm::DESCEND_ACTOR_TREE:
 279     {
 280       if( actor.IsVisible() ) // Actor is visible, if not visible then none of its children are visible.
 281       {
 282         hittable = true;
 283       }
 284       break;
 285     }
 286     default:
 287     {
 288       break;
 289     }
 290   }
 291
 292   return hittable;
 293 }
 294
 295 } // unnamed namespace
 296
 297
 298 /****************************************************************************************************/
 299 /****************************************************************************************************/
 300 /********************************   TEST CASES BELOW   **********************************************/
 301 /****************************************************************************************************/
 302 /****************************************************************************************************/
 303
 304 int UtcDaliRenderTaskDownCast(void)
 305 {
 306   TestApplication application;
 307
 308   tet_infoline("Testing RenderTask::DownCast()");
 309
 310   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 311
 312   BaseHandle base = taskList.GetTask( 0u );
 313   DALI_TEST_CHECK( base );
 314
 315   RenderTask task = RenderTask::DownCast( base );
 316   DALI_TEST_CHECK( task );
 317
 318   // Try calling a method
 319   DALI_TEST_CHECK( task.GetSourceActor() );
 320   END_TEST;
 321 }
 322
 323 int UtcDaliRenderTaskSetSourceActor(void)
 324 {
 325   TestApplication application;
 326
 327   tet_infoline("Testing RenderTask::SetSourceActor()");
 328
 329   Stage stage = Stage::GetCurrent();
 330
 331   const std::vector<GLuint>& boundTextures = application.GetGlAbstraction().GetBoundTextures( GL_TEXTURE0 );
 332
 333   RenderTaskList taskList = stage.GetRenderTaskList();
 334
 335   RenderTask task = taskList.GetTask( 0u );
 336
 337   Actor actor = task.GetSourceActor();
 338   DALI_TEST_CHECK( actor );
 339
 340   std::vector<GLuint> ids;
 341   ids.push_back( 7 );
 342   application.GetGlAbstraction().SetNextTextureIds( ids );
 343
 344   BufferImage img = BufferImage::New( 1,1 );
 345   ImageActor newActor = ImageActor::New( img );
 346   newActor.SetSize(1,1);
 347   stage.Add( newActor );
 348
 349   Actor nonRenderableActor = Actor::New();
 350   stage.Add( nonRenderableActor );
 351
 352   // Stop the newActor from being rendered by changing the source actor
 353   DALI_TEST_CHECK( nonRenderableActor );
 354   task.SetSourceActor( nonRenderableActor );
 355   DALI_TEST_CHECK( task.GetSourceActor() != actor );
 356   DALI_TEST_CHECK( task.GetSourceActor() == nonRenderableActor );
 357
 358   // Update & Render nothing!
 359   application.GetGlAbstraction().ClearBoundTextures();
 360   application.SendNotification();
 361   application.Render();
 362
 363   // Check that nothing was rendered
 364   DALI_TEST_EQUALS( boundTextures.size(), 0u, TEST_LOCATION );
 365
 366   // Set newActor as the new source Actor
 367   task.SetSourceActor( newActor );
 368   DALI_TEST_CHECK( task.GetSourceActor() != actor );
 369   DALI_TEST_CHECK( task.GetSourceActor() == newActor );
 370
 371   // Update & Render the newActor
 372   application.GetGlAbstraction().ClearBoundTextures();
 373   application.SendNotification();
 374   application.Render();
 375
 376   // Check that the newActor was rendered
 377   DALI_TEST_EQUALS( boundTextures.size(), 1u, TEST_LOCATION );
 378   if ( boundTextures.size() )
 379   {
 380     DALI_TEST_EQUALS( boundTextures[0], 7u, TEST_LOCATION );
 381   }
 382   END_TEST;
 383 }
 384
 385 int UtcDaliRenderTaskSetSourceActorOffStage(void)
 386 {
 387   TestApplication application;
 388
 389   tet_infoline("Testing RenderTask::SetSourceActor (on/off stage testing)");
 390
 391   Stage stage = Stage::GetCurrent();
 392
 393   const std::vector<GLuint>& boundTextures = application.GetGlAbstraction().GetBoundTextures( GL_TEXTURE0 );
 394
 395   RenderTaskList taskList = stage.GetRenderTaskList();
 396
 397   RenderTask task = taskList.GetTask( 0u );
 398
 399   Actor actor = task.GetSourceActor();
 400   DALI_TEST_CHECK( actor );
 401
 402   std::vector<GLuint> ids;
 403   GLuint expectedTextureId( 3 );
 404   ids.push_back( expectedTextureId );
 405   application.GetGlAbstraction().SetNextTextureIds( ids );
 406
 407   BufferImage img = BufferImage::New( 1,1 );
 408   ImageActor newActor = ImageActor::New( img );
 409   newActor.SetSize(1,1);
 410   task.SetSourceActor( newActor );
 411   // Don't add newActor to stage yet
 412
 413   // Update & Render with the actor initially off-stage
 414   application.GetGlAbstraction().ClearBoundTextures();
 415   application.SendNotification();
 416   application.Render();
 417
 418   // Check that nothing was rendered
 419   DALI_TEST_EQUALS( boundTextures.size(), 0u, TEST_LOCATION );
 420
 421   // Now add to stage
 422   stage.Add( newActor );
 423
 424   // Update & Render with the actor on-stage
 425   application.GetGlAbstraction().ClearBoundTextures();
 426   application.SendNotification();
 427   application.Render();
 428
 429   // Check that the newActor was rendered
 430   DALI_TEST_EQUALS( boundTextures.size(), 1u, TEST_LOCATION );
 431   if ( boundTextures.size() )
 432   {
 433     DALI_TEST_EQUALS( boundTextures[0], expectedTextureId, TEST_LOCATION );
 434   }
 435
 436   // Now remove from stage
 437   stage.Remove( newActor );
 438
 439   // Update & Render with the actor off-stage
 440   application.GetGlAbstraction().ClearBoundTextures();
 441   application.SendNotification();
 442   application.Render();
 443   END_TEST;
 444 }
 445
 446 int UtcDaliRenderTaskSetSourceActorEmpty(void)
 447 {
 448   TestApplication application;
 449
 450   tet_infoline("Testing RenderTask::SetSourceActor (empty handle case)");
 451
 452   Stage stage = Stage::GetCurrent();
 453
 454   const std::vector<GLuint>& boundTextures = application.GetGlAbstraction().GetBoundTextures( GL_TEXTURE0 );
 455
 456   RenderTaskList taskList = stage.GetRenderTaskList();
 457
 458   RenderTask task = taskList.GetTask( 0u );
 459
 460   Actor actor = task.GetSourceActor();
 461   DALI_TEST_CHECK( actor );
 462
 463   std::vector<GLuint> ids;
 464   GLuint expectedTextureId( 5 );
 465   ids.push_back( expectedTextureId );
 466   application.GetGlAbstraction().SetNextTextureIds( ids );
 467
 468   BufferImage img = BufferImage::New( 1,1 );
 469   ImageActor newActor = ImageActor::New( img );
 470   newActor.SetSize(1,1);
 471   stage.Add( newActor );
 472
 473   Actor nonRenderableActor = Actor::New();
 474   stage.Add( nonRenderableActor );
 475
 476   // Set with empty handle
 477   task.SetSourceActor( Actor() );
 478   DALI_TEST_CHECK( ! task.GetSourceActor() );
 479
 480   // Update & Render nothing!
 481   application.GetGlAbstraction().ClearBoundTextures();
 482   application.SendNotification();
 483   application.Render();
 484
 485   // Check that nothing was rendered
 486   DALI_TEST_EQUALS( boundTextures.size(), 0u, TEST_LOCATION );
 487
 488   // Set with non-empty handle
 489   task.SetSourceActor( newActor );
 490   DALI_TEST_CHECK( task.GetSourceActor() == newActor );
 491
 492   // Update & Render the newActor
 493   application.GetGlAbstraction().ClearBoundTextures();
 494   application.SendNotification();
 495   application.Render();
 496
 497   // Check that the newActor was rendered
 498   DALI_TEST_EQUALS( boundTextures.size(), 1u, TEST_LOCATION );
 499   if ( boundTextures.size() )
 500   {
 501     DALI_TEST_EQUALS( boundTextures[0], expectedTextureId, TEST_LOCATION );
 502   }
 503   END_TEST;
 504 }
 505
 506 int UtcDaliRenderTaskGetSourceActor(void)
 507 {
 508   TestApplication application;
 509
 510   tet_infoline("Testing RenderTask::GetSourceActor()");
 511
 512   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 513
 514   RenderTask task = taskList.GetTask( 0u );
 515
 516   Actor actor = task.GetSourceActor();
 517   DALI_TEST_CHECK( actor );
 518
 519   // By default the entire scene should be rendered
 520   Actor root = Stage::GetCurrent().GetLayer( 0 );
 521   DALI_TEST_CHECK( root == actor );
 522   END_TEST;
 523 }
 524
 525 int UtcDaliRenderTaskSetExclusive(void)
 526 {
 527   TestApplication application;
 528
 529   tet_infoline("Testing RenderTask::SetExclusive()");
 530
 531   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 532
 533   // Manipulate the GenTextures behaviour, to identify different ImageActors
 534
 535   std::vector<GLuint> ids;
 536   ids.push_back( 8 ); // 8 = actor1
 537   ids.push_back( 9 ); // 9 = actor2
 538   ids.push_back( 10 ); // 10 = actor3
 539   application.GetGlAbstraction().SetNextTextureIds( ids );
 540
 541   BufferImage img1 = BufferImage::New( 1,1 );
 542   ImageActor actor1 = ImageActor::New( img1 );
 543   actor1.SetSize(1,1);
 544   Stage::GetCurrent().Add( actor1 );
 545
 546   // Update & Render actor1
 547   application.SendNotification();
 548   application.Render();
 549
 550   // Check that the actor1 was rendered
 551   const std::vector<GLuint>& boundTextures = application.GetGlAbstraction().GetBoundTextures( GL_TEXTURE0 );
 552   DALI_TEST_EQUALS( boundTextures.size(), 1u, TEST_LOCATION );
 553
 554   if ( boundTextures.size() )
 555   {
 556     DALI_TEST_EQUALS( boundTextures[0], 8u/*unique to actor1*/, TEST_LOCATION );
 557   }
 558
 559   BufferImage img2 = BufferImage::New( 1,1 );
 560   ImageActor actor2 = ImageActor::New( img2 );
 561   actor2.SetSize(1,1);
 562
 563   // Force actor2 to be rendered before actor1
 564   Layer layer = Layer::New();
 565   Stage::GetCurrent().Add( layer );
 566   layer.Add( actor2 );
 567   layer.LowerToBottom();
 568
 569   // Update & Render
 570   application.GetGlAbstraction().ClearBoundTextures();
 571   application.SendNotification();
 572   application.Render();
 573
 574   // Check that the actors were rendered
 575   DALI_TEST_EQUALS( boundTextures.size(), 2u, TEST_LOCATION );
 576
 577   if ( boundTextures.size() )
 578   {
 579     DALI_TEST_EQUALS( boundTextures[0], 9u/*unique to actor2*/, TEST_LOCATION );
 580     DALI_TEST_EQUALS( boundTextures[1], 8u/*unique to actor1*/, TEST_LOCATION );
 581   }
 582
 583   BufferImage img3 = BufferImage::New( 1,1 );
 584   ImageActor actor3 = ImageActor::New( img3 );
 585   actor3.SetSize(1,1);
 586
 587   // Force actor3 to be rendered before actor2
 588   layer = Layer::New();
 589   Stage::GetCurrent().Add( layer );
 590   layer.Add( actor3 );
 591   layer.LowerToBottom();
 592
 593   // Update & Render all actors
 594   application.GetGlAbstraction().ClearBoundTextures();
 595   application.SendNotification();
 596   application.Render();
 597
 598   // Check that the actors were rendered
 599   DALI_TEST_EQUALS( boundTextures.size(), 3u, TEST_LOCATION );
 600
 601   if ( boundTextures.size() )
 602   {
 603     DALI_TEST_EQUALS( boundTextures[0], 10u/*unique to actor3*/, TEST_LOCATION );
 604     DALI_TEST_EQUALS( boundTextures[1], 9u/*unique to actor2*/, TEST_LOCATION );
 605     DALI_TEST_EQUALS( boundTextures[2], 8u/*unique to actor1*/, TEST_LOCATION );
 606   }
 607
 608   // Both actors are now connected to the root node
 609   // Setup 2 render-tasks - the first will render from the root-node, and the second from actor2
 610
 611   // Not exclusive is the default
 612   RenderTask task1 = taskList.GetTask( 0u );
 613   DALI_TEST_CHECK( false == task1.IsExclusive() );
 614
 615   RenderTask task2 = taskList.CreateTask();
 616   DALI_TEST_CHECK( false == task2.IsExclusive() );
 617   task2.SetSourceActor( actor2 );
 618
 619   // Task1 should render all actors, and task 2 should render only actor2
 620
 621   application.GetGlAbstraction().ClearBoundTextures();
 622   application.SendNotification();
 623   application.Render();
 624
 625   DALI_TEST_EQUALS( boundTextures.size(), 4u, TEST_LOCATION );
 626
 627   if ( boundTextures.size() == 4 )
 628   {
 629     // Test that task 1 renders actor3, then actor2 & then actor1
 630     DALI_TEST_CHECK( boundTextures[0] == 10u );
 631     DALI_TEST_CHECK( boundTextures[1] == 9u );
 632     DALI_TEST_CHECK( boundTextures[2] == 8u );
 633
 634     // Test that task 2 renders actor2
 635     DALI_TEST_EQUALS( boundTextures[3], 9u, TEST_LOCATION );
 636   }
 637
 638   // Make actor2 exclusive to task2
 639
 640   task2.SetExclusive( true );
 641   DALI_TEST_CHECK( true == task2.IsExclusive() );
 642
 643   // Task1 should render only actor1, and task 2 should render only actor2
 644
 645   application.GetGlAbstraction().ClearBoundTextures();
 646   application.SendNotification();
 647   application.Render();
 648
 649   DALI_TEST_EQUALS( boundTextures.size(), 3u, TEST_LOCATION );
 650   if ( boundTextures.size() == 3 )
 651   {
 652     // Test that task 1 renders actor3 & actor1
 653     DALI_TEST_CHECK( boundTextures[0] == 10u );
 654     DALI_TEST_CHECK( boundTextures[1] == 8u );
 655
 656     // Test that task 2 renders actor2
 657     DALI_TEST_CHECK( boundTextures[2] == 9u );
 658   }
 659   END_TEST;
 660 }
 661
 662 int UtcDaliRenderTaskIsExclusive(void)
 663 {
 664   TestApplication application;
 665
 666   tet_infoline("Testing RenderTask::IsExclusive()");
 667
 668   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 669
 670   // Not exclusive is the default
 671   RenderTask task = taskList.GetTask( 0u );
 672   DALI_TEST_CHECK( false == task.IsExclusive() );
 673
 674   RenderTask newTask = taskList.CreateTask();
 675   DALI_TEST_CHECK( false == newTask.IsExclusive() );
 676   END_TEST;
 677 }
 678
 679 int UtcDaliRenderTaskSetInputEnabled(void)
 680 {
 681   TestApplication application;
 682
 683   tet_infoline("Testing RenderTask::SetInputEnabled()");
 684
 685   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 686
 687   // Input is enabled by default
 688   RenderTask task = taskList.GetTask( 0u );
 689   DALI_TEST_CHECK( true == task.GetInputEnabled() );
 690
 691   task.SetInputEnabled( false );
 692   DALI_TEST_CHECK( false == task.GetInputEnabled() );
 693
 694   task.SetInputEnabled( true );
 695   DALI_TEST_CHECK( true == task.GetInputEnabled() );
 696   END_TEST;
 697 }
 698
 699 int UtcDaliRenderTaskGetInputEnabled(void)
 700 {
 701   TestApplication application;
 702
 703   tet_infoline("Testing RenderTask::GetInputEnabled()");
 704
 705   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 706
 707   // Input is enabled by default
 708   RenderTask task = taskList.GetTask( 0u );
 709   DALI_TEST_CHECK( true == task.GetInputEnabled() );
 710
 711   RenderTask newTask = taskList.CreateTask();
 712   DALI_TEST_CHECK( true == newTask.GetInputEnabled() );
 713   END_TEST;
 714 }
 715
 716 int UtcDaliRenderTaskSetCameraActor(void)
 717 {
 718   TestApplication application;
 719
 720   tet_infoline("Testing RenderTask::SetCameraActor()");
 721
 722   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 723
 724   RenderTask task = taskList.GetTask( 0u );
 725
 726   Actor actor = task.GetCameraActor();
 727   DALI_TEST_CHECK( actor );
 728
 729   CameraActor newActor = CameraActor::New();
 730   DALI_TEST_CHECK( newActor );
 731
 732   task.SetCameraActor( newActor );
 733   DALI_TEST_CHECK( task.GetCameraActor() != actor );
 734   DALI_TEST_CHECK( task.GetCameraActor() == newActor );
 735   END_TEST;
 736 }
 737
 738 int UtcDaliRenderTaskGetCameraActor(void)
 739 {
 740   TestApplication application;
 741
 742   tet_infoline("Testing RenderTask::GetCameraActor()");
 743
 744   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 745
 746   RenderTask task = taskList.GetTask( 0u );
 747
 748   Actor actor = task.GetCameraActor();
 749   DALI_TEST_CHECK( actor );
 750
 751   RenderTask newTask = taskList.CreateTask();
 752   DALI_TEST_CHECK( actor == newTask.GetCameraActor() );
 753   END_TEST;
 754 }
 755
 756 int UtcDaliRenderTaskSetTargetFrameBuffer(void)
 757 {
 758   TestApplication application;
 759
 760   tet_infoline("Testing RenderTask::SetTargetFrameBuffer()");
 761
 762   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 763
 764   RenderTask task = taskList.GetTask( 0u );
 765
 766   // By default render-tasks do not render off-screen
 767   FrameBufferImage image = task.GetTargetFrameBuffer();
 768   DALI_TEST_CHECK( !image );
 769
 770   FrameBufferImage newImage = FrameBufferImage::New();
 771
 772   task.SetTargetFrameBuffer( newImage );
 773   DALI_TEST_CHECK( task.GetTargetFrameBuffer() == newImage );
 774   END_TEST;
 775 }
 776
 777 int UtcDaliRenderTaskGetTargetFrameBuffer(void)
 778 {
 779   TestApplication application;
 780
 781   tet_infoline("Testing RenderTask::GetTargetFrameBuffer()");
 782
 783   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 784
 785   RenderTask task = taskList.GetTask( 0u );
 786
 787   // By default render-tasks do not render off-screen
 788   FrameBufferImage image = task.GetTargetFrameBuffer();
 789   DALI_TEST_CHECK( !image );
 790
 791   RenderTask newTask = taskList.CreateTask();
 792   DALI_TEST_CHECK( !newTask.GetTargetFrameBuffer() );
 793   END_TEST;
 794 }
 795
 796 int UtcDaliRenderTaskSetScreenToFrameBufferFunction(void)
 797 {
 798   TestApplication application;
 799
 800   tet_infoline("Testing RenderTask::SetScreenToFrameBufferFunction()");
 801
 802   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 803
 804   RenderTask task = taskList.GetTask( 0u );
 805
 806   task.SetScreenToFrameBufferFunction( TestScreenToFrameBufferFunction );
 807
 808   Vector2 coordinates( 5, 10 );
 809   Vector2 convertedCoordinates( 6, 12 ); // + Vector(1, 2)
 810
 811   RenderTask::ScreenToFrameBufferFunction func = task.GetScreenToFrameBufferFunction();
 812   DALI_TEST_CHECK( func( coordinates ) );
 813   DALI_TEST_CHECK( coordinates == convertedCoordinates );
 814
 815   task.SetScreenToFrameBufferFunction( RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION );
 816   func = task.GetScreenToFrameBufferFunction();
 817   DALI_TEST_CHECK( func( coordinates ) );
 818
 819   task.SetScreenToFrameBufferFunction( RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION );
 820   func = task.GetScreenToFrameBufferFunction();
 821   DALI_TEST_CHECK( ! func( coordinates ) );
 822   END_TEST;
 823 }
 824
 825 int UtcDaliRenderTaskGetScreenToFrameBufferFunction(void)
 826 {
 827   TestApplication application;
 828
 829   tet_infoline("Testing RenderTask::GetScreenToFrameBufferFunction()");
 830
 831   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 832
 833   RenderTask task = taskList.GetTask( 0u );
 834
 835   Vector2 originalCoordinates( 5, 10 );
 836   Vector2 coordinates( 5, 10 );
 837
 838   RenderTask::ScreenToFrameBufferFunction func = task.GetScreenToFrameBufferFunction();
 839   DALI_TEST_CHECK( !func( coordinates ) ); // conversion should fail by default
 840   DALI_TEST_CHECK( coordinates == originalCoordinates ); // coordinates should not be modified
 841   END_TEST;
 842 }
 843
 844
 845 int UtcDaliRenderTaskGetScreenToFrameBufferMappingActor(void)
 846 {
 847   TestApplication application;
 848   tet_infoline("Testing RenderTask::GetScreenToFrameBufferMappingActor ");
 849
 850   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 851   RenderTask renderTask = taskList.CreateTask();
 852   Actor mappingActor = Actor::New();
 853   renderTask.SetScreenToFrameBufferMappingActor(mappingActor);
 854
 855   DALI_TEST_CHECK( mappingActor == renderTask.GetScreenToFrameBufferMappingActor() );
 856   END_TEST;
 857 }
 858
 859 int UtcDaliRenderTaskSetViewport(void)
 860 {
 861   TestApplication application;
 862
 863   tet_infoline("Testing RenderTask::SetViewport()");
 864
 865   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 866
 867   RenderTask task = taskList.GetTask( 0u );
 868
 869   Viewport viewport = task.GetViewport();
 870
 871   // By default the viewport should match the stage width/height
 872
 873   Vector2 stageSize = Stage::GetCurrent().GetSize();
 874   Viewport expectedViewport( 0, 0, stageSize.width, stageSize.height );
 875   DALI_TEST_CHECK( viewport == expectedViewport );
 876
 877   Viewport newViewport( 0, 0, stageSize.width * 0.5f, stageSize.height * 0.5f );
 878   task.SetViewport( newViewport );
 879
 880   // Update (viewport is a property)
 881   application.SendNotification();
 882   application.Render();
 883
 884   DALI_TEST_CHECK( task.GetViewport() == newViewport );
 885   END_TEST;
 886 }
 887
 888 int UtcDaliRenderTaskGetViewport(void)
 889 {
 890   TestApplication application;
 891
 892   tet_infoline("Testing RenderTask::GetViewport()");
 893
 894   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 895
 896   RenderTask task = taskList.GetTask( 0u );
 897
 898   Viewport viewport = task.GetViewport();
 899
 900   // By default the viewport should match the stage width/height
 901
 902   Vector2 stageSize = Stage::GetCurrent().GetSize();
 903   Viewport expectedViewport( 0, 0, stageSize.width, stageSize.height );
 904   DALI_TEST_CHECK( viewport == expectedViewport );
 905
 906   RenderTask newTask = taskList.CreateTask();
 907   DALI_TEST_CHECK( newTask.GetViewport() == expectedViewport );
 908   END_TEST;
 909 }
 910
 911 int UtcDaliRenderTaskSetViewportPosition(void)
 912 {
 913   TestApplication application;
 914
 915   tet_infoline("Testing RenderTask::SetViewportPosition()");
 916
 917   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 918
 919   RenderTask task = taskList.GetTask( 0u );
 920
 921   Viewport viewport = task.GetViewport();
 922
 923   // By default the viewport should match the stage width/height
 924
 925   Vector2 stageSize = Stage::GetCurrent().GetSize();
 926   Viewport expectedViewport( 0, 0, stageSize.width, stageSize.height );
 927   DALI_TEST_CHECK( viewport == expectedViewport );
 928
 929   // 'Setter' test
 930   Vector2 newPosition(25.0f, 50.0f);
 931   task.SetViewportPosition( newPosition );
 932
 933   // Update (viewport is a property)
 934   application.SendNotification();
 935   application.Render();
 936
 937   DALI_TEST_EQUALS( task.GetCurrentViewportPosition(), newPosition, Math::MACHINE_EPSILON_1, TEST_LOCATION );
 938
 939   // Set by Property test
 940   Vector2 newPosition2(32.0f, 32.0f);
 941   task.SetProperty( RenderTask::Property::VIEWPORT_POSITION, newPosition2 );
 942
 943   // Update
 944   application.SendNotification();
 945   application.Render();
 946
 947   DALI_TEST_EQUALS( task.GetCurrentViewportPosition(), newPosition2, Math::MACHINE_EPSILON_1, TEST_LOCATION );
 948
 949   Vector2 newPosition3(64.0f, 0.0f);
 950   Animation animation = Animation::New(1.0f);
 951   animation.AnimateTo( Property( task, RenderTask::Property::VIEWPORT_POSITION ), newPosition3, AlphaFunctions::Linear );
 952   animation.Play();
 953
 954   // Perform 1000ms worth of updates at which point animation should have completed.
 955   Wait(application, 1000);
 956   DALI_TEST_EQUALS( task.GetCurrentViewportPosition(), newPosition3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
 957   END_TEST;
 958 }
 959
 960 int UtcDaliRenderTaskSetViewportSize(void)
 961 {
 962   TestApplication application;
 963
 964   tet_infoline("Testing RenderTask::SetViewportSize()");
 965
 966   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 967
 968   RenderTask task = taskList.GetTask( 0u );
 969
 970   Viewport viewport = task.GetViewport();
 971
 972   // By default the viewport should match the stage width/height
 973
 974   Vector2 stageSize = Stage::GetCurrent().GetSize();
 975   Viewport expectedViewport( 0, 0, stageSize.width, stageSize.height );
 976   DALI_TEST_CHECK( viewport == expectedViewport );
 977
 978   Vector2 newSize(128.0f, 64.0f);
 979   task.SetViewportSize( newSize );
 980
 981   // Update (viewport is a property)
 982   application.SendNotification();
 983   application.Render();
 984
 985   DALI_TEST_EQUALS( task.GetCurrentViewportSize(), newSize, Math::MACHINE_EPSILON_1, TEST_LOCATION );
 986
 987   // Set by Property test
 988   Vector2 newSize2(50.0f, 50.0f);
 989   task.SetProperty( RenderTask::Property::VIEWPORT_SIZE, newSize2 );
 990
 991   // Update
 992   application.SendNotification();
 993   application.Render();
 994
 995   DALI_TEST_EQUALS( task.GetCurrentViewportSize(), newSize2, Math::MACHINE_EPSILON_1, TEST_LOCATION );
 996
 997   Vector2 newSize3(10.0f, 10.0f);
 998   Animation animation = Animation::New(1.0f);
 999   animation.AnimateTo( Property( task, RenderTask::Property::VIEWPORT_SIZE ), newSize3, AlphaFunctions::Linear );
1000   animation.Play();
1001
1002   // Perform 1000ms worth of updates at which point animation should have completed.
1003   Wait(application, 1000);
1004   DALI_TEST_EQUALS( task.GetCurrentViewportSize(), newSize3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1005
1006   END_TEST;
1007 }
1008
1009 int UtcDaliRenderTaskSetClearColor(void)
1010 {
1011   TestApplication application;
1012
1013   tet_infoline("Testing RenderTask::SetClearColor()");
1014
1015   Vector4 testColor( 1.0f, 2.0f, 3.0f, 4.0f );
1016   Vector4 testColor2( 5.0f, 6.0f, 7.0f, 8.0f );
1017
1018   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1019
1020   RenderTask task = taskList.GetTask( 0u );
1021   DALI_TEST_CHECK( task.GetClearColor() != testColor );
1022
1023   task.SetClearColor( testColor );
1024
1025   // Wait a frame.
1026   Wait(application);
1027
1028   DALI_TEST_EQUALS( task.GetClearColor(), testColor, TEST_LOCATION );
1029
1030   task.SetProperty( RenderTask::Property::CLEAR_COLOR, testColor2 );
1031
1032   // Wait a frame.
1033   Wait(application);
1034
1035   DALI_TEST_EQUALS( task.GetClearColor(), testColor2, TEST_LOCATION );
1036   END_TEST;
1037 }
1038
1039 int UtcDaliRenderTaskGetClearColor(void)
1040 {
1041   TestApplication application;
1042
1043   tet_infoline("Testing RenderTask::GetClearColor()");
1044
1045   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1046   RenderTask task = taskList.GetTask( 0u );
1047   DALI_TEST_EQUALS( task.GetClearColor(), RenderTask::DEFAULT_CLEAR_COLOR, TEST_LOCATION );
1048   END_TEST;
1049 }
1050
1051 int UtcDaliRenderTaskSetClearEnabled(void)
1052 {
1053   TestApplication application;
1054
1055   tet_infoline("Testing RenderTask::SetClearEnabled()");
1056
1057   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1058
1059   RenderTask task = taskList.GetTask( 0u );
1060   DALI_TEST_CHECK( !task.GetClearEnabled() ); // defaults to false
1061
1062   task.SetClearEnabled( true );
1063   DALI_TEST_EQUALS( task.GetClearEnabled(), true, TEST_LOCATION );
1064
1065   task.SetClearEnabled( false );
1066   DALI_TEST_EQUALS( task.GetClearEnabled(), false, TEST_LOCATION );
1067   END_TEST;
1068 }
1069
1070 int UtcDaliRenderTaskGetClearEnabled(void)
1071 {
1072   TestApplication application;
1073
1074   tet_infoline("Testing RenderTask::GetClearEnabled()");
1075
1076   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1077
1078   RenderTask task = taskList.GetTask( 0u );
1079   DALI_TEST_CHECK( !task.GetClearEnabled() ); // defaults to false
1080   END_TEST;
1081 }
1082
1083 int UtcDaliRenderTaskSetRefreshRate(void)
1084 {
1085   TestApplication application;
1086
1087   tet_infoline("Testing RenderTask::SetRefreshRate()");
1088
1089   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1090
1091   // By default tasks will be processed every frame
1092   RenderTask task = taskList.GetTask( 0u );
1093   DALI_TEST_CHECK( RenderTask::REFRESH_ALWAYS == task.GetRefreshRate() );
1094
1095   task.SetRefreshRate( 2u ); // every-other frame
1096   DALI_TEST_CHECK( 2u == task.GetRefreshRate() );
1097
1098   task.SetRefreshRate( RenderTask::REFRESH_ALWAYS );
1099   DALI_TEST_CHECK( RenderTask::REFRESH_ALWAYS == task.GetRefreshRate() );
1100   END_TEST;
1101 }
1102
1103 int UtcDaliRenderTaskGetRefreshRate(void)
1104 {
1105   TestApplication application;
1106
1107   tet_infoline("Testing RenderTask::GetRefreshRate()");
1108
1109   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1110
1111   // By default tasks will be processed every frame
1112   RenderTask task = taskList.GetTask( 0u );
1113   DALI_TEST_CHECK( RenderTask::REFRESH_ALWAYS == task.GetRefreshRate() );
1114
1115   RenderTask newTask = taskList.CreateTask();
1116   DALI_TEST_CHECK( RenderTask::REFRESH_ALWAYS == newTask.GetRefreshRate() );
1117   END_TEST;
1118 }
1119
1120 int UtcDaliRenderTaskSignalFinished(void)
1121 {
1122   TestApplication application;
1123
1124   tet_infoline("Testing RenderTask::SignalFinished()");
1125
1126   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1127   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
1128
1129   CameraActor offscreenCameraActor = CameraActor::New();
1130
1131   Stage::GetCurrent().Add( offscreenCameraActor );
1132
1133   BufferImage image = BufferImage::New( 10, 10 );
1134   ImageActor rootActor = ImageActor::New( image );
1135   rootActor.SetSize( 10, 10 );
1136   Stage::GetCurrent().Add( rootActor );
1137
1138   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1139   NativeImageInterfacePtr testNativeImagePtr = TestNativeImage::New(10, 10);
1140   FrameBufferImage frameBufferImage = FrameBufferImage::New( *testNativeImagePtr.Get() );
1141
1142   // Flush all outstanding messages
1143   application.SendNotification();
1144   application.Render();
1145
1146   RenderTask newTask = taskList.CreateTask();
1147   newTask.SetCameraActor( offscreenCameraActor );
1148   newTask.SetSourceActor( rootActor );
1149   newTask.SetInputEnabled( false );
1150   newTask.SetClearColor( Vector4( 0.f, 0.f, 0.f, 0.f ) );
1151   newTask.SetClearEnabled( true );
1152   newTask.SetExclusive( true );
1153   newTask.SetRefreshRate( RenderTask::REFRESH_ONCE );
1154   newTask.SetTargetFrameBuffer( frameBufferImage );
1155
1156   // Framebuffer doesn't actually get created until Connected, i.e. by previous line
1157
1158   bool finished = false;
1159   RenderTaskFinished renderTaskFinished( finished );
1160   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1161
1162   // Flush the queue and render.
1163   application.SendNotification();
1164
1165   // 1 render to process render task, then wait for sync before finished msg is sent
1166   // from update to the event thread.
1167
1168   application.Render();
1169   application.SendNotification();
1170   DALI_TEST_CHECK( !finished );
1171
1172   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
1173   DALI_TEST_CHECK( lastSyncObj != NULL );
1174
1175   application.Render();
1176   DALI_TEST_EQUALS( (application.GetUpdateStatus() & Integration::KeepUpdating::RENDER_TASK_SYNC), Integration::KeepUpdating::RENDER_TASK_SYNC, TEST_LOCATION );
1177   application.SendNotification();
1178   DALI_TEST_CHECK( !finished );
1179
1180   application.Render();
1181   DALI_TEST_EQUALS( (application.GetUpdateStatus() & Integration::KeepUpdating::RENDER_TASK_SYNC), Integration::KeepUpdating::RENDER_TASK_SYNC, TEST_LOCATION );
1182   application.SendNotification();
1183   DALI_TEST_CHECK( ! finished );
1184
1185   sync.SetObjectSynced( lastSyncObj, true );
1186
1187   application.Render();
1188   application.SendNotification();
1189   DALI_TEST_CHECK( !finished );
1190
1191   application.Render();
1192   application.SendNotification();
1193   DALI_TEST_CHECK( finished );
1194   finished = false;
1195
1196   application.Render(); // Double check no more finished signal
1197   application.SendNotification();
1198   DALI_TEST_CHECK( ! finished );
1199   END_TEST;
1200 }
1201
1202
1203 int UtcDaliRenderTaskContinuous01(void)
1204 {
1205   TestApplication application;
1206
1207   tet_infoline("Testing RenderTask Render Continuous using loading image\nPRE: render task not ready (source actor not staged)\nPOST:continuous renders, no Finished signal");
1208
1209   // SETUP AN OFFSCREEN RENDER TASK
1210   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1211   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1212   drawTrace.Enable(true);
1213
1214   Actor rootActor = Actor::New();
1215   Stage::GetCurrent().Add( rootActor );
1216
1217   CameraActor offscreenCameraActor = CameraActor::New();
1218   Stage::GetCurrent().Add( offscreenCameraActor );
1219
1220   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1221   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1222   Integration::ResourceId imageRequestId = imageRequest->GetId();
1223   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1224
1225   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1226   bool finished = false;
1227   RenderTaskFinished renderTaskFinished( finished );
1228   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1229   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1230   application.SendNotification();
1231
1232   // START PROCESS/RENDER                     Input,    Expected  Input, Expected, KeepUpdating
1233   DALI_TEST_CHECK( UpdateRender(application,  drawTrace, false,   finished, false, false ) );
1234   application.GetPlatform().ClearReadyResources();
1235
1236   // ADD SOURCE ACTOR TO STAGE - expect continuous renders to start, no finished signal
1237   Stage::GetCurrent().Add(secondRootActor);
1238   application.SendNotification();
1239
1240   // CONTINUE PROCESS/RENDER                  Input,    Expected  Input,    Expected
1241   DALI_TEST_CHECK( UpdateRender(application,  drawTrace, true,    finished, false, false ) );
1242   END_TEST;
1243 }
1244
1245
1246 int UtcDaliRenderTaskContinuous02(void)
1247 {
1248   TestApplication application;
1249
1250   tet_infoline("Testing RenderTask Render Continuous using loading image\nPRE: render task not ready (source actor not visible)\nPOST:continuous renders, no Finished signal");
1251
1252   // SETUP AN OFFSCREEN RENDER TASK
1253   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1254   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1255   drawTrace.Enable(true);
1256
1257   Actor rootActor = Actor::New();
1258   Stage::GetCurrent().Add( rootActor );
1259
1260   CameraActor offscreenCameraActor = CameraActor::New();
1261   Stage::GetCurrent().Add( offscreenCameraActor );
1262
1263   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1264   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1265   Integration::ResourceId imageRequestId = imageRequest->GetId();
1266   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1267   Stage::GetCurrent().Add(secondRootActor);
1268   secondRootActor.SetVisible(false);
1269
1270   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1271   bool finished = false;
1272   RenderTaskFinished renderTaskFinished( finished );
1273   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1274   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1275   application.SendNotification();
1276
1277   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected, KeepUpdating
1278   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, false ) );
1279   application.GetPlatform().ClearReadyResources();
1280
1281   // MAKE SOURCE ACTOR VISIBLE - expect continuous renders to start, no finished signal
1282   secondRootActor.SetVisible(true);
1283   application.SendNotification();
1284
1285   // CONTINUE PROCESS/RENDER                 Input,    Expected  Input,    Expected
1286   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
1287   END_TEST;
1288 }
1289
1290 int UtcDaliRenderTaskContinuous03(void)
1291 {
1292   TestApplication application;
1293
1294   tet_infoline("Testing RenderTask Render Continuous using loading image\nPRE: render task not ready (camera actor not staged)\nPOST:continuous renders, no Finished signal");
1295
1296   // SETUP AN OFFSCREEN RENDER TASK
1297   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1298   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1299   drawTrace.Enable(true);
1300
1301   Actor rootActor = Actor::New();
1302   Stage::GetCurrent().Add( rootActor );
1303
1304   CameraActor offscreenCameraActor = CameraActor::New();
1305   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1306   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1307   Integration::ResourceId imageRequestId = imageRequest->GetId();
1308   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1309   Stage::GetCurrent().Add(secondRootActor);
1310
1311   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1312   bool finished = false;
1313   RenderTaskFinished renderTaskFinished( finished );
1314   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1315   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1316   application.SendNotification();
1317
1318   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1319   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, false ) );
1320   application.GetPlatform().ClearReadyResources();
1321
1322   // ADD CAMERA ACTOR TO STAGE - expect continuous renders to start, no finished signal
1323   Stage::GetCurrent().Add( offscreenCameraActor );
1324   application.SendNotification();
1325
1326   // CONTINUE PROCESS/RENDER                 Input,    Expected  Input,    Expected
1327   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
1328   END_TEST;
1329 }
1330
1331
1332 int UtcDaliRenderTaskContinuous04(void)
1333 {
1334   TestApplication application;
1335
1336   tet_infoline("Testing RenderTask Render Continuous using loading image\nPRE: Resource not ready\nPOST:continuous renders, no Finished signal");
1337
1338   // SETUP AN OFFSCREEN RENDER TASK
1339   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1340   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1341   drawTrace.Enable(true);
1342
1343   Actor rootActor = Actor::New();
1344   Stage::GetCurrent().Add( rootActor );
1345
1346   CameraActor offscreenCameraActor = CameraActor::New();
1347   Stage::GetCurrent().Add( offscreenCameraActor );
1348   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1349   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1350   Integration::ResourceId imageRequestId = imageRequest->GetId();
1351   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1352   Stage::GetCurrent().Add(secondRootActor);
1353
1354   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1355   bool finished = false;
1356   RenderTaskFinished renderTaskFinished( finished );
1357   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1358   application.SendNotification();
1359
1360   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1361   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1362   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1363
1364   // FINISH RESOURCE LOADING - expect 'continuous' renders to start, no finished signal
1365   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1366   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
1367   END_TEST;
1368 }
1369
1370
1371 int UtcDaliRenderTaskOnce01(void)
1372 {
1373   TestApplication application;
1374
1375   tet_infoline("Testing RenderTask Render Once GlSync, using loading image\nPRE: Resources not ready, Source not visible\nPOST: Finished signal sent once only");
1376
1377   // SETUP AN OFFSCREEN RENDER TASK
1378   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1379   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
1380   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1381   drawTrace.Enable(true);
1382
1383   Actor rootActor = Actor::New();
1384   Stage::GetCurrent().Add( rootActor );
1385
1386   CameraActor offscreenCameraActor = CameraActor::New();
1387   Stage::GetCurrent().Add( offscreenCameraActor );
1388   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1389   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1390   Integration::ResourceId imageRequestId = imageRequest->GetId();
1391   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1392
1393   Stage::GetCurrent().Add(secondRootActor);
1394
1395   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, true);
1396   bool finished = false;
1397   RenderTaskFinished renderTaskFinished( finished );
1398   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1399   application.SendNotification();
1400
1401   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1402   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1403   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1404
1405   // MAKE SOURCE VISIBLE
1406   secondRootActor.SetVisible(true);
1407   application.SendNotification();
1408   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1409   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1410
1411   // FINISH RESOURCE LOADING - expect no rendering yet
1412   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1413   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1414   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
1415   DALI_TEST_CHECK( lastSyncObj != NULL );
1416
1417   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1418   application.GetPlatform().ClearReadyResources();
1419   sync.SetObjectSynced( lastSyncObj, true );
1420   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,   finished, false, true  ) );
1421   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
1422   END_TEST;
1423 }
1424
1425 int UtcDaliRenderTaskOnce02(void)
1426 {
1427   TestApplication application;
1428
1429   tet_infoline("Testing RenderTask Render Once GlSync, using loading image. Switch from render always after ready to render once\n"
1430                "PRE: Render task ready, Image not loaded\n"
1431                "POST: Finished signal sent only once");
1432
1433   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
1434   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1435   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
1436   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1437   drawTrace.Enable(true);
1438
1439   Actor rootActor = Actor::New();
1440   Stage::GetCurrent().Add( rootActor );
1441
1442   CameraActor offscreenCameraActor = CameraActor::New();
1443   Stage::GetCurrent().Add( offscreenCameraActor );
1444   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1445   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1446   Integration::ResourceId imageRequestId = imageRequest->GetId();
1447   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1448   Stage::GetCurrent().Add(secondRootActor);
1449
1450   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1451   bool finished = false;
1452   RenderTaskFinished renderTaskFinished( finished );
1453   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1454   application.SendNotification();
1455
1456   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1457   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1458   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1459
1460   // FINISH RESOURCE LOADING
1461   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1462   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
1463   application.GetPlatform().ClearReadyResources();
1464   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
1465
1466   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
1467   application.SendNotification(); //         Input,    Expected  Input,    Expected
1468   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1469   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
1470   DALI_TEST_CHECK( lastSyncObj != NULL );
1471
1472   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1473   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1474   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1475   sync.SetObjectSynced( lastSyncObj, true );
1476   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true  ) );
1477   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
1478
1479   END_TEST;
1480 }
1481
1482
1483 int UtcDaliRenderTaskOnce03(void)
1484 {
1485   TestApplication application;
1486
1487   tet_infoline("Testing RenderTask Render Once GlSync\n"
1488                "Switch from Render always after ready to render once with resources unready\n"
1489                "PRE: Everything ready to render\n"
1490                "POST: Finished signal sent once");
1491
1492   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
1493   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1494   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
1495   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1496   drawTrace.Enable(true);
1497
1498   Actor rootActor = Actor::New();
1499   Stage::GetCurrent().Add( rootActor );
1500
1501   CameraActor offscreenCameraActor = CameraActor::New();
1502   Stage::GetCurrent().Add( offscreenCameraActor );
1503   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1504   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1505   Integration::ResourceId imageRequestId = imageRequest->GetId();
1506   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1507   Stage::GetCurrent().Add(secondRootActor);
1508
1509   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1510   bool finished = false;
1511   RenderTaskFinished renderTaskFinished( finished );
1512   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1513   application.SendNotification();
1514
1515   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1516   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1517   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1518
1519   // CHANGE TO RENDER ONCE
1520   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
1521   application.SendNotification(); //         Input,    Expected  Input,    Expected
1522   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1523   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1524
1525   // FINISH RESOURCE LOADING
1526   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1527   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1528   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
1529   DALI_TEST_CHECK( lastSyncObj != NULL );
1530   application.GetPlatform().ClearReadyResources();
1531
1532   sync.SetObjectSynced( lastSyncObj, true );
1533   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true  ) );
1534   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
1535
1536   END_TEST;
1537 }
1538
1539 #if 0
1540 //int UtcDaliRenderTaskOnce04(void)
1541 {
1542   TestApplication application;
1543
1544   tet_infoline("Testing RenderTask Render Once GlSync\n"
1545                "During RenderOnce, make ready resources unready before sending first finished signal\n"
1546                "PRE: Everything ready.\n"
1547                "POST: Finished signal sent only once");
1548
1549   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
1550   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1551   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
1552   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1553   drawTrace.Enable(true);
1554
1555   Actor rootActor = Actor::New();
1556   Stage::GetCurrent().Add( rootActor );
1557
1558   CameraActor offscreenCameraActor = CameraActor::New();
1559   Stage::GetCurrent().Add( offscreenCameraActor );
1560   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1561   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1562   Integration::ResourceId imageRequestId = imageRequest->GetId();
1563   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1564   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1565   application.Render();
1566
1567   Stage::GetCurrent().Add(secondRootActor);
1568   application.GetPlatform().ClearReadyResources();
1569
1570   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1571   bool finished = false;
1572   RenderTaskFinished renderTaskFinished( finished );
1573   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1574   application.SendNotification();
1575
1576   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1577   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1578   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1579
1580   // CHANGE TO RENDER ONCE, RESOURCES BECOME NOT READY
1581   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
1582
1583   // Doesn't work...
1584   ReloadImage(application, secondRootActor.GetImage());
1585   application.SendNotification(); //         Input,    Expected  Input,    Expected
1586
1587   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1588   DALI_TEST_EQUALS( secondRootActor.GetImage().GetLoadingState(), Dali::ResourceLoading, TEST_LOCATION);
1589   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1590
1591   // FINISH RESOURCE LOADING
1592   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1593   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1594   application.GetPlatform().ClearReadyResources();
1595   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
1596   DALI_TEST_CHECK( lastSyncObj != NULL );
1597
1598   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1599   sync.SetObjectSynced( lastSyncObj, true );
1600   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true  ) );
1601   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, true  ) );
1602
1603   // Finished rendering - expect no more renders, no more signals:
1604   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1605   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1606   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1607   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1608   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1609   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1610   END_TEST;
1611 }
1612 #endif
1613
1614 int UtcDaliRenderTaskOnce05(void)
1615 {
1616   TestApplication application;
1617
1618   tet_infoline("Testing RenderTask Render Once GLSync\n"
1619                "Render once, Second call to SetRefreshRate(ONCE) triggers only one more finished signal\n"
1620                "PRE: Everything ready\n"
1621                "POST: exactly 1 finished signal per call to SetRefreshRate(ONCE)");
1622
1623   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
1624   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1625   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
1626   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1627   drawTrace.Enable(true);
1628
1629   Actor rootActor = Actor::New();
1630   Stage::GetCurrent().Add( rootActor );
1631
1632   CameraActor offscreenCameraActor = CameraActor::New();
1633   Stage::GetCurrent().Add( offscreenCameraActor );
1634   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1635   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1636   Integration::ResourceId imageRequestId = imageRequest->GetId();
1637   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1638   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1639   application.Render();
1640   application.GetPlatform().ClearReadyResources();
1641
1642   Stage::GetCurrent().Add(secondRootActor);
1643
1644   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1645   bool finished = false;
1646   RenderTaskFinished renderTaskFinished( finished );
1647   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1648   application.SendNotification();
1649
1650   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1651   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
1652
1653   // CHANGE TO RENDER ONCE,
1654   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
1655   application.SendNotification();
1656   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1657   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
1658   DALI_TEST_CHECK( lastSyncObj != NULL );
1659
1660   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1661   sync.SetObjectSynced( lastSyncObj, true );
1662   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1663   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true,  false  ) );
1664
1665   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
1666   application.SendNotification();
1667   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1668   lastSyncObj = sync.GetLastSyncObject();
1669   DALI_TEST_CHECK( lastSyncObj != NULL );
1670
1671   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1672   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1673   sync.SetObjectSynced( lastSyncObj, true );
1674   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1675   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
1676   END_TEST;
1677 }
1678
1679 int UtcDaliRenderTaskOnce06(void)
1680 {
1681   TestApplication application;
1682
1683   tet_infoline("Testing RenderTask Render Once GLSync\n"
1684                "Render once, Call to SetRefreshRate(ONCE) in Finished signal callback triggers "
1685                "another render & another finished signal\n"
1686                "PRE: Everything ready\n"
1687                "POST: exactly 1 finished signal per call to SetRefreshRate(ONCE)");
1688
1689
1690   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
1691   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1692   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
1693   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1694   drawTrace.Enable(true);
1695
1696   Actor rootActor = Actor::New();
1697   Stage::GetCurrent().Add( rootActor );
1698
1699   CameraActor offscreenCameraActor = CameraActor::New();
1700   Stage::GetCurrent().Add( offscreenCameraActor );
1701   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1702   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1703   Integration::ResourceId imageRequestId = imageRequest->GetId();
1704   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1705   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1706   application.Render();
1707   application.GetPlatform().ClearReadyResources();
1708
1709   Stage::GetCurrent().Add(secondRootActor);
1710
1711   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1712   bool finished = false;
1713
1714   ConnectionTracker connectionTracker;
1715   RenderTaskFinishedRenderAgain renderTaskFinishedRenderAgain( finished );
1716   newTask.FinishedSignal().Connect( &connectionTracker, renderTaskFinishedRenderAgain );
1717
1718   application.SendNotification();
1719
1720   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1721   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
1722   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
1723   DALI_TEST_CHECK( lastSyncObj == NULL );
1724
1725   // CHANGE TO RENDER ONCE,
1726   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
1727   application.SendNotification();
1728   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1729   lastSyncObj = sync.GetLastSyncObject();
1730   DALI_TEST_CHECK( lastSyncObj != NULL );
1731
1732   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1733   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1734
1735   sync.SetObjectSynced( lastSyncObj, true );
1736   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1737   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
1738   application.SendNotification();
1739
1740   // Expect SetRefreshRate to have been called again
1741   // Prevent next finished signal calling refresh once again
1742   RenderTaskFinished renderTaskFinished( finished );
1743   connectionTracker.DisconnectAll();
1744   newTask.FinishedSignal().Connect( &connectionTracker, renderTaskFinished );
1745   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1746   lastSyncObj = sync.GetLastSyncObject();
1747   DALI_TEST_CHECK( lastSyncObj != NULL );
1748
1749   sync.SetObjectSynced( lastSyncObj, true );
1750   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1751   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
1752   END_TEST;
1753 }
1754
1755
1756 int UtcDaliRenderTaskOnce07(void)
1757 {
1758   TestApplication application;
1759
1760   tet_infoline("Testing RenderTask Render Once GlSync\n"
1761                "SetRefreshRate(ONCE) again before first finished signal has been sent.\n"
1762                "PRE: resources ready\n"
1763                "POST: Only 1 finished signal sent.");
1764
1765   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
1766   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1767   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
1768   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1769   drawTrace.Enable(true);
1770
1771   Actor rootActor = Actor::New();
1772   Stage::GetCurrent().Add( rootActor );
1773
1774   CameraActor offscreenCameraActor = CameraActor::New();
1775   Stage::GetCurrent().Add( offscreenCameraActor );
1776   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1777   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1778   Integration::ResourceId imageRequestId = imageRequest->GetId();
1779   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1780   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1781   application.Render();
1782   application.GetPlatform().ClearReadyResources();
1783
1784   Stage::GetCurrent().Add(secondRootActor);
1785
1786   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1787   bool finished = false;
1788   RenderTaskFinished renderTaskFinished( finished );
1789   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1790   application.SendNotification();
1791
1792   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1793   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
1794
1795   // CHANGE TO RENDER ONCE,
1796   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
1797   application.SendNotification();
1798   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1799   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1800   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1801
1802   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
1803   application.SendNotification();
1804   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1805   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
1806   DALI_TEST_CHECK( lastSyncObj != NULL );
1807
1808   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1809   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1810   sync.SetObjectSynced( lastSyncObj, true );
1811   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1812   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
1813
1814   END_TEST;
1815 }
1816
1817
1818
1819 int UtcDaliRenderTaskOnce08(void)
1820 {
1821   TestApplication application;
1822
1823   tet_infoline("Testing RenderTask Render Once GlSync\n"
1824                "SetRefreshRate(ONCE), resource load failed completes render task.\n"
1825                "PRE: resources not ready\n"
1826                "POST: Only 1 finished signal sent.");
1827
1828   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
1829   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1830   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
1831   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1832   drawTrace.Enable(true);
1833
1834   Actor rootActor = Actor::New();
1835   Stage::GetCurrent().Add( rootActor );
1836
1837   CameraActor offscreenCameraActor = CameraActor::New();
1838   Stage::GetCurrent().Add( offscreenCameraActor );
1839   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1840   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1841   Integration::ResourceId imageRequestId = imageRequest->GetId();
1842   Stage::GetCurrent().Add(secondRootActor);
1843
1844   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1845   bool finished = false;
1846   RenderTaskFinished renderTaskFinished( finished );
1847   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1848   application.SendNotification();
1849
1850   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1851   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1852   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1853
1854   // CHANGE TO RENDER ONCE,
1855   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
1856   application.SendNotification();
1857   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1858   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1859   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1860
1861   tet_printf("  FailImageLoad\n");
1862
1863   FailImageLoad(application, imageRequestId); // Need to run Update again for this to complete
1864   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) ); // nothing to draw
1865   application.SendNotification();
1866
1867   // Drawing empty framebuffer, so will still get a GL sync
1868   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
1869   DALI_TEST_CHECK( lastSyncObj != NULL );
1870
1871   // Expect finished signal, as all resources are complete
1872   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,   finished, true, false ) );
1873
1874   END_TEST;
1875 }
1876
1877
1878
1879 int UtcDaliRenderTaskOnceNoSync01(void)
1880 {
1881   TestApplication application;
1882
1883   tet_infoline("Testing RenderTask Render Once, using loading image\nPRE: Resources not ready, Source not visible\nPOST: Finished signal sent once only");
1884
1885   // SETUP AN OFFSCREEN RENDER TASK
1886   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1887   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1888   drawTrace.Enable(true);
1889
1890   Actor rootActor = Actor::New();
1891   Stage::GetCurrent().Add( rootActor );
1892
1893   CameraActor offscreenCameraActor = CameraActor::New();
1894   Stage::GetCurrent().Add( offscreenCameraActor );
1895   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1896   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1897   Integration::ResourceId imageRequestId = imageRequest->GetId();
1898   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1899
1900   Stage::GetCurrent().Add(secondRootActor);
1901
1902   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, false);
1903   bool finished = false;
1904   RenderTaskFinished renderTaskFinished( finished );
1905   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1906   application.SendNotification();
1907
1908   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1909   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1910   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1911
1912   // FINISH RESOURCE LOADING - expect immediate rendering yet
1913   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1914   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1915   application.GetPlatform().ClearReadyResources();
1916   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false ) );
1917   END_TEST;
1918 }
1919
1920 int UtcDaliRenderTaskOnceNoSync02(void)
1921 {
1922   TestApplication application;
1923
1924   tet_infoline("Testing RenderTask Render Once, using loading image. Switch from render always after ready to render once\n"
1925                "PRE: Render task ready, Image not loaded\n"
1926                "POST: Finished signal sent only once");
1927
1928   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
1929   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1930   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1931   drawTrace.Enable(true);
1932
1933   Actor rootActor = Actor::New();
1934   Stage::GetCurrent().Add( rootActor );
1935
1936   CameraActor offscreenCameraActor = CameraActor::New();
1937   Stage::GetCurrent().Add( offscreenCameraActor );
1938   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1939   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1940   Integration::ResourceId imageRequestId = imageRequest->GetId();
1941   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1942   Stage::GetCurrent().Add(secondRootActor);
1943
1944   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
1945   bool finished = false;
1946   RenderTaskFinished renderTaskFinished( finished );
1947   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1948   application.SendNotification();
1949
1950   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1951   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1952   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1953
1954   // FINISH RESOURCE LOADING
1955   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1956   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
1957   application.GetPlatform().ClearReadyResources();
1958
1959   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
1960   application.SendNotification(); //         Input,    Expected  Input,    Expected
1961   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1962   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
1963   END_TEST;
1964 }
1965
1966
1967 int UtcDaliRenderTaskOnceNoSync03(void)
1968 {
1969   TestApplication application;
1970
1971   tet_infoline("Testing RenderTask Render Once\n"
1972                "Switch from Render always after ready to render once with resources unready\n"
1973                "PRE: Everything ready to render\n"
1974                "POST: Finished signal sent once");
1975
1976   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
1977   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1978   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1979   drawTrace.Enable(true);
1980
1981   Actor rootActor = Actor::New();
1982   Stage::GetCurrent().Add( rootActor );
1983
1984   CameraActor offscreenCameraActor = CameraActor::New();
1985   Stage::GetCurrent().Add( offscreenCameraActor );
1986   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1987   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1988   Integration::ResourceId imageRequestId = imageRequest->GetId();
1989   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1990   Stage::GetCurrent().Add(secondRootActor);
1991
1992   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
1993   bool finished = false;
1994   RenderTaskFinished renderTaskFinished( finished );
1995   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1996   application.SendNotification();
1997
1998   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1999   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2000   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2001
2002   // CHANGE TO RENDER ONCE
2003   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2004   application.SendNotification(); //         Input,    Expected  Input,    Expected
2005   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2006   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2007
2008   // FINISH RESOURCE LOADING
2009   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2010   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2011   application.GetPlatform().ClearReadyResources();
2012   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
2013   END_TEST;
2014 }
2015
2016 #if 0
2017 //int UtcDaliRenderTaskOnceNoSync04(void)
2018 {
2019   TestApplication application;
2020
2021   tet_infoline("Testing RenderTask Render Once\n"
2022                "During RenderOnce, make ready resources unready before sending first finished signal\n"
2023                "PRE: Everything ready.\n"
2024                "POST: Finished signal sent only once");
2025
2026   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2027   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2028   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2029   drawTrace.Enable(true);
2030
2031   Actor rootActor = Actor::New();
2032   Stage::GetCurrent().Add( rootActor );
2033
2034   CameraActor offscreenCameraActor = CameraActor::New();
2035   Stage::GetCurrent().Add( offscreenCameraActor );
2036   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
2037   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
2038   Integration::ResourceId imageRequestId = imageRequest->GetId();
2039   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
2040   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2041   application.Render();
2042   application.GetPlatform().ClearReadyResources();
2043
2044   Stage::GetCurrent().Add(secondRootActor);
2045
2046   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
2047   bool finished = false;
2048   RenderTaskFinished renderTaskFinished( finished );
2049   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2050   application.SendNotification();
2051
2052   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2053   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2054   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
2055
2056   // CHANGE TO RENDER ONCE, RESOURCES BECOME NOT READY
2057   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2058
2059   // Doesn't work...
2060   ReloadImage(application, secondRootActor.GetImage());
2061   application.SendNotification(); //         Input,    Expected  Input,    Expected
2062
2063   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2064   DALI_TEST_EQUALS( secondRootActor.GetImage().GetLoadingState(), Dali::ResourceLoading, TEST_LOCATION);
2065   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2066
2067   // FINISH RESOURCE LOADING
2068   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2069   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, true, true ) );
2070   application.GetPlatform().ClearReadyResources();
2071   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2072   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true  ) );
2073   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2074   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2075   END_TEST;
2076 }
2077 #endif
2078
2079 int UtcDaliRenderTaskOnceNoSync05(void)
2080 {
2081   TestApplication application;
2082
2083   tet_infoline("Testing RenderTask Render Once\n"
2084                "Render once, Second call to SetRefreshRate(ONCE) triggers only one more finished signal\n"
2085                "PRE: Everything ready\n"
2086                "POST: exactly 1 finished signal per call to SetRefreshRate(ONCE)");
2087
2088   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2089   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2090   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2091   drawTrace.Enable(true);
2092
2093   Actor rootActor = Actor::New();
2094   Stage::GetCurrent().Add( rootActor );
2095
2096   CameraActor offscreenCameraActor = CameraActor::New();
2097   Stage::GetCurrent().Add( offscreenCameraActor );
2098   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
2099   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
2100   Integration::ResourceId imageRequestId = imageRequest->GetId();
2101   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
2102   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2103   application.Render();
2104   application.GetPlatform().ClearReadyResources();
2105
2106   Stage::GetCurrent().Add(secondRootActor);
2107
2108   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
2109   bool finished = false;
2110   RenderTaskFinished renderTaskFinished( finished );
2111   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2112   application.SendNotification();
2113
2114   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2115   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
2116
2117   // CHANGE TO RENDER ONCE,
2118   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2119   application.SendNotification();
2120   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2121   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true,  false ) );
2122
2123   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2124   application.SendNotification();
2125   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2126   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true,  false ) );
2127   END_TEST;
2128 }
2129
2130 int UtcDaliRenderTaskOnceNoSync06(void)
2131 {
2132   TestApplication application;
2133
2134   tet_infoline("Testing RenderTask Render Once\n"
2135                "Render once, Call to SetRefreshRate(ONCE) in Finished signal callback triggers\n"
2136                "another render & another finished signal\n"
2137                "PRE: Everything ready\n"
2138                "POST: exactly 1 finished signal per call to SetRefreshRate(ONCE)");
2139
2140
2141   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2142   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2143   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2144   drawTrace.Enable(true);
2145
2146   Actor rootActor = Actor::New();
2147   Stage::GetCurrent().Add( rootActor );
2148
2149   CameraActor offscreenCameraActor = CameraActor::New();
2150   Stage::GetCurrent().Add( offscreenCameraActor );
2151   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
2152   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
2153   Integration::ResourceId imageRequestId = imageRequest->GetId();
2154   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
2155   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2156   application.Render();
2157   application.GetPlatform().ClearReadyResources();
2158
2159   Stage::GetCurrent().Add(secondRootActor);
2160
2161   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
2162   bool finished = false;
2163
2164   ConnectionTracker connectionTracker;
2165   RenderTaskFinishedRenderAgain renderTaskFinishedRenderAgain( finished );
2166   newTask.FinishedSignal().Connect( &connectionTracker, renderTaskFinishedRenderAgain );
2167
2168   application.SendNotification();
2169
2170   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2171   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
2172
2173   // CHANGE TO RENDER ONCE,
2174   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2175   application.SendNotification();
2176   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2177   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true,  false ) );
2178
2179   // Expect SetRefreshRate to have been called again
2180   // Prevent next finished signal calling refresh once again
2181   RenderTaskFinished renderTaskFinished( finished );
2182   connectionTracker.DisconnectAll();
2183   newTask.FinishedSignal().Connect( &connectionTracker, renderTaskFinished );
2184
2185   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2186   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true,  false ) );
2187   END_TEST;
2188 }
2189
2190
2191 int UtcDaliRenderTaskOnceNoSync07(void)
2192 {
2193   TestApplication application;
2194
2195   tet_infoline("Testing RenderTask Render Once\n"
2196                "SetRefreshRate(ONCE) again before first finished signal has been sent.\n"
2197                "PRE: resources ready\n"
2198                "POST: Only 1 finished signal sent.");
2199
2200   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2201   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2202   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2203   drawTrace.Enable(true);
2204
2205   Actor rootActor = Actor::New();
2206   Stage::GetCurrent().Add( rootActor );
2207
2208   CameraActor offscreenCameraActor = CameraActor::New();
2209   Stage::GetCurrent().Add( offscreenCameraActor );
2210   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
2211   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
2212   Integration::ResourceId imageRequestId = imageRequest->GetId();
2213   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
2214   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2215   application.Render();
2216   application.GetPlatform().ClearReadyResources();
2217
2218   Stage::GetCurrent().Add(secondRootActor);
2219
2220   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
2221   bool finished = false;
2222   RenderTaskFinished renderTaskFinished( finished );
2223   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2224   application.SendNotification();
2225
2226   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2227   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
2228
2229   // CHANGE TO RENDER ONCE,
2230   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2231   application.SendNotification();
2232   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2233   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true,  false ) );
2234
2235   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2236   application.SendNotification();
2237   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2238   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true,  false ) );
2239   END_TEST;
2240 }
2241
2242 int UtcDaliRenderTaskOnceNoSync08(void)
2243 {
2244   TestApplication application;
2245
2246   tet_infoline("Testing RenderTask Render Once\n"
2247                "SetRefreshRate(ONCE), resource load failed, completes render task.\n"
2248                "PRE: resources not ready\n"
2249                "POST: Only 1 finished signal sent.");
2250
2251   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2252   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2253   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2254   drawTrace.Enable(true);
2255
2256   Actor rootActor = Actor::New();
2257   Stage::GetCurrent().Add( rootActor );
2258
2259   CameraActor offscreenCameraActor = CameraActor::New();
2260   Stage::GetCurrent().Add( offscreenCameraActor );
2261   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
2262   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
2263   Integration::ResourceId imageRequestId = imageRequest->GetId();
2264   Stage::GetCurrent().Add(secondRootActor);
2265
2266   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
2267   bool finished = false;
2268   RenderTaskFinished renderTaskFinished( finished );
2269   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2270   application.SendNotification();
2271
2272   // START PROCESS/RENDER                    Input,     Expected  Input,    Expected
2273   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2274   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2275
2276   // CHANGE TO RENDER ONCE,
2277   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2278   application.SendNotification();
2279   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2280   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2281   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2282
2283   FailImageLoad(application, imageRequestId); // Need to run Update again for this to complete
2284   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) ); // nothing to draw
2285   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, true,  false  ) );
2286
2287   END_TEST;
2288 }
2289
2290
2291
2292 int UtcDaliRenderTaskOnceChain01(void)
2293 {
2294   TestApplication application;
2295
2296   tet_infoline("Testing RenderTask Render Once Chained render tasks\n"
2297                "SetRefreshRate(ONCE), resource load completes, both render tasks render.\n"
2298                "PRE: resources not ready\n"
2299                "POST: 2 finished signals sent.");
2300
2301   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2302   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2303   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2304   drawTrace.Enable(true);
2305
2306   Actor defaultRootActor = Actor::New(); // Root for default RT
2307   Stage::GetCurrent().Add( defaultRootActor );
2308
2309   CameraActor offscreenCameraActor = CameraActor::New();
2310   Stage::GetCurrent().Add( offscreenCameraActor );
2311   ImageActor firstRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
2312   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
2313   Integration::ResourceId imageRequestId = imageRequest->GetId();
2314   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
2315   Stage::GetCurrent().Add(firstRootActor);
2316
2317   // first render task
2318   RenderTask firstTask = CreateRenderTask(application, offscreenCameraActor, defaultRootActor, firstRootActor, RenderTask::REFRESH_ONCE, false);
2319   bool firstFinished = false;
2320   RenderTaskFinished renderTask1Finished( firstFinished );
2321   firstTask.FinishedSignal().Connect( &application, renderTask1Finished );
2322
2323   // Second render task
2324   FrameBufferImage fbo = firstTask.GetTargetFrameBuffer();
2325   ImageActor secondRootActor = ImageActor::New( fbo );
2326   Stage::GetCurrent().Add(secondRootActor);
2327   RenderTask secondTask = CreateRenderTask(application, offscreenCameraActor, defaultRootActor, secondRootActor, RenderTask::REFRESH_ONCE, false);
2328   bool secondFinished = false;
2329   RenderTaskFinished renderTask2Finished( secondFinished );
2330   secondTask.FinishedSignal().Connect( &application, renderTask2Finished );
2331
2332   application.SendNotification();
2333
2334   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2335   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,  firstFinished, false, true ) );
2336   DALI_TEST_CHECK( secondFinished == false );
2337   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,  firstFinished, false, true ) );
2338   DALI_TEST_CHECK( secondFinished == false );
2339
2340   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2341   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,  firstFinished, false, true ) );
2342   DALI_TEST_CHECK( secondFinished == false );
2343   application.GetPlatform().ClearReadyResources();
2344
2345   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,  firstFinished, true,  false ) );
2346   DALI_TEST_CHECK( secondFinished == true );
2347
2348   END_TEST;
2349 }
2350
2351 int UtcDaliRenderTaskProperties(void)
2352 {
2353   TestApplication application;
2354
2355   RenderTask task = Stage::GetCurrent().GetRenderTaskList().CreateTask();
2356
2357   Property::IndexContainer indices;
2358   task.GetPropertyIndices( indices );
2359   DALI_TEST_CHECK( ! indices.empty() );
2360   DALI_TEST_EQUALS( indices.size(), task.GetPropertyCount(), TEST_LOCATION );
2361   END_TEST;
2362 }
2363
2364 int UtcDaliRenderTaskSetScreenToFrameBufferMappingActor(void)
2365 {
2366   TestApplication application;
2367   tet_infoline("Testing RenderTask::SetScreenToFrameBufferMappingActor ");
2368
2369   Stage stage = Stage::GetCurrent();
2370   Size stageSize = stage.GetSize();
2371   Actor mappingActor = Actor::New();
2372   Vector2 scale( 0.6f, 0.75f);
2373   Vector2 offset( stageSize.x*0.1f, stageSize.y*0.15f);
2374   mappingActor.SetSize( stageSize * scale );
2375   mappingActor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
2376   mappingActor.SetPosition( offset.x, offset.y );
2377   stage.Add( mappingActor );
2378
2379   Actor offscreenActor = Actor::New();
2380   offscreenActor.SetSize( stageSize );
2381   offscreenActor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
2382   stage.Add( offscreenActor );
2383
2384   RenderTaskList taskList = stage.GetRenderTaskList();
2385   RenderTask renderTask = taskList.CreateTask();
2386   FrameBufferImage frameBufferImage =  FrameBufferImage::New(stageSize.width*scale.x, stageSize.height*scale.y, Pixel::A8, Image::NEVER);
2387   renderTask.SetSourceActor( offscreenActor );
2388   renderTask.SetExclusive( true );
2389   renderTask.SetInputEnabled( true );
2390   renderTask.SetTargetFrameBuffer( frameBufferImage );
2391   renderTask.SetRefreshRate( RenderTask::REFRESH_ONCE );
2392   renderTask.SetScreenToFrameBufferMappingActor( mappingActor );
2393   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2394
2395   // Render and notify
2396   application.SendNotification();
2397   application.Render();
2398   application.Render();
2399   application.SendNotification();
2400
2401   Vector2 screenCoordinates( stageSize.x * 0.05f, stageSize.y * 0.05f );
2402   Dali::HitTestAlgorithm::Results results;
2403   DALI_TEST_CHECK( !results.actor );
2404   DALI_TEST_EQUALS( Vector2::ZERO, results.actorCoordinates, 0.1f, TEST_LOCATION );
2405   // miss expected, results not changed
2406   DALI_TEST_CHECK( false == Dali::HitTestAlgorithm::HitTest( renderTask, screenCoordinates, results, IsActorHittableFunction ) );
2407   DALI_TEST_CHECK( !results.actor );
2408   DALI_TEST_EQUALS( Vector2::ZERO, results.actorCoordinates, 0.1f, TEST_LOCATION );
2409
2410   screenCoordinates.x = stageSize.x * 0.265f;
2411   screenCoordinates.y = stageSize.y * 0.33f;
2412   results.actor = Actor();
2413   results.actorCoordinates = Vector2::ZERO;
2414   // hit expected, results changed
2415   DALI_TEST_CHECK( true == Dali::HitTestAlgorithm::HitTest( renderTask, screenCoordinates, results, IsActorHittableFunction ) );
2416   DALI_TEST_CHECK( results.actor  == offscreenActor );
2417   DALI_TEST_EQUALS( (screenCoordinates-offset)/scale , results.actorCoordinates, 0.1f, TEST_LOCATION );
2418
2419   screenCoordinates.x = stageSize.x * 0.435f;
2420   screenCoordinates.y = stageSize.y * 0.52f;
2421   // hit expected, results changed
2422   DALI_TEST_CHECK( true == Dali::HitTestAlgorithm::HitTest( renderTask, screenCoordinates, results, IsActorHittableFunction ) );
2423   DALI_TEST_CHECK( results.actor  == offscreenActor );
2424   const Vector2 expectedCoordinates = (screenCoordinates-offset)/scale;
2425   DALI_TEST_EQUALS( expectedCoordinates , results.actorCoordinates, 0.1f, TEST_LOCATION );
2426
2427   screenCoordinates.x = stageSize.x * 0.65f;
2428   screenCoordinates.y = stageSize.y * 0.95f;
2429   // miss expected, results not changed
2430   DALI_TEST_CHECK( false == Dali::HitTestAlgorithm::HitTest( renderTask, screenCoordinates, results, IsActorHittableFunction ) );
2431   DALI_TEST_CHECK( results.actor  == offscreenActor );
2432   DALI_TEST_EQUALS( expectedCoordinates , results.actorCoordinates, 0.1f, TEST_LOCATION );
2433   END_TEST;
2434 }
2435
2436 int UtcDaliRenderTaskFinishInvisibleSourceActor(void)
2437 {
2438   TestApplication application;
2439
2440   tet_infoline("Testing RenderTask::SignalFinished()");
2441
2442   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2443   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
2444
2445   CameraActor offscreenCameraActor = CameraActor::New();
2446
2447   Stage::GetCurrent().Add( offscreenCameraActor );
2448
2449   BufferImage image = BufferImage::New( 10, 10 );
2450   ImageActor rootActor = ImageActor::New( image );
2451   rootActor.SetSize( 10, 10 );
2452   rootActor.SetVisible(false);
2453   Stage::GetCurrent().Add( rootActor );
2454
2455   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
2456   NativeImageInterfacePtr testNativeImagePtr = TestNativeImage::New(10, 10);
2457   FrameBufferImage frameBufferImage = FrameBufferImage::New( *testNativeImagePtr.Get() );
2458
2459   // Flush all outstanding messages
2460   application.SendNotification();
2461   application.Render();
2462
2463   RenderTask newTask = taskList.CreateTask();
2464   newTask.SetCameraActor( offscreenCameraActor );
2465   newTask.SetSourceActor( rootActor );
2466   newTask.SetInputEnabled( false );
2467   newTask.SetClearColor( Vector4( 0.f, 0.f, 0.f, 0.f ) );
2468   newTask.SetClearEnabled( true );
2469   newTask.SetExclusive( true );
2470   newTask.SetRefreshRate( RenderTask::REFRESH_ONCE );
2471   newTask.SetTargetFrameBuffer( frameBufferImage );
2472
2473   // Framebuffer doesn't actually get created until Connected, i.e. by previous line
2474
2475   bool finished = false;
2476   RenderTaskFinished renderTaskFinished( finished );
2477   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2478
2479   // Flush the queue and render.
2480   application.SendNotification();
2481
2482   // 1 render to process render task, then wait for sync before finished msg is sent
2483   // from update to the event thread.
2484
2485   application.Render();
2486   application.SendNotification();
2487   DALI_TEST_CHECK( !finished );
2488
2489   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
2490   DALI_TEST_CHECK( lastSyncObj != NULL );
2491
2492   application.Render();
2493   DALI_TEST_EQUALS( (application.GetUpdateStatus() & Integration::KeepUpdating::RENDER_TASK_SYNC), Integration::KeepUpdating::RENDER_TASK_SYNC, TEST_LOCATION );
2494   application.SendNotification();
2495   DALI_TEST_CHECK( !finished );
2496
2497   application.Render();
2498   DALI_TEST_EQUALS( (application.GetUpdateStatus() & Integration::KeepUpdating::RENDER_TASK_SYNC), Integration::KeepUpdating::RENDER_TASK_SYNC, TEST_LOCATION );
2499   application.SendNotification();
2500   DALI_TEST_CHECK( ! finished );
2501
2502   sync.SetObjectSynced( lastSyncObj, true );
2503
2504   application.Render();
2505   application.SendNotification();
2506   DALI_TEST_CHECK( !finished );
2507
2508   application.Render();
2509   application.SendNotification();
2510   DALI_TEST_CHECK( finished );
2511   finished = false;
2512
2513   application.Render(); // Double check no more finished signal
2514   application.SendNotification();
2515   DALI_TEST_CHECK( ! finished );
2516
2517   END_TEST;
2518 }