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   BitmapImage img = BitmapImage::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   BitmapImage img = BitmapImage::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   BitmapImage img = BitmapImage::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   BitmapImage img1 = BitmapImage::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   BitmapImage img2 = BitmapImage::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   BitmapImage img3 = BitmapImage::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::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::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::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::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::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   BitmapImage image = BitmapImage::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, true ) );
1234   application.GetPlatform().ClearReadyResources();
1235
1236   DALI_TEST_CHECK( UpdateRender(application,  drawTrace, false,   finished, false, false ) );
1237
1238   // ADD SOURCE ACTOR TO STAGE - expect continuous renders to start, no finished signal
1239   Stage::GetCurrent().Add(secondRootActor);
1240   application.SendNotification();
1241
1242   // CONTINUE PROCESS/RENDER                  Input,    Expected  Input,    Expected
1243   DALI_TEST_CHECK( UpdateRender(application,  drawTrace, true,    finished, false, true ) );
1244   DALI_TEST_CHECK( UpdateRender(application,  drawTrace, true,    finished, false, false ) );
1245   END_TEST;
1246 }
1247
1248
1249 int UtcDaliRenderTaskContinuous02(void)
1250 {
1251   TestApplication application;
1252
1253   tet_infoline("Testing RenderTask Render Continuous using loading image\nPRE: render task not ready (source actor not visible)\nPOST:continuous renders, no Finished signal");
1254
1255   // SETUP AN OFFSCREEN RENDER TASK
1256   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1257   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1258   drawTrace.Enable(true);
1259
1260   Actor rootActor = Actor::New();
1261   Stage::GetCurrent().Add( rootActor );
1262
1263   CameraActor offscreenCameraActor = CameraActor::New();
1264   Stage::GetCurrent().Add( offscreenCameraActor );
1265
1266   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1267   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1268   Integration::ResourceId imageRequestId = imageRequest->GetId();
1269   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1270   Stage::GetCurrent().Add(secondRootActor);
1271   secondRootActor.SetVisible(false);
1272
1273   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1274   bool finished = false;
1275   RenderTaskFinished renderTaskFinished( finished );
1276   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1277   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1278   application.SendNotification();
1279
1280   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1281   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1282   application.GetPlatform().ClearReadyResources();
1283   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, false ) );
1284
1285   // MAKE SOURCE ACTOR VISIBLE - expect continuous renders to start, no finished signal
1286   secondRootActor.SetVisible(true);
1287   application.SendNotification();
1288
1289   // CONTINUE PROCESS/RENDER                 Input,    Expected  Input,    Expected
1290   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1291   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
1292   END_TEST;
1293 }
1294
1295 int UtcDaliRenderTaskContinuous03(void)
1296 {
1297   TestApplication application;
1298
1299   tet_infoline("Testing RenderTask Render Continuous using loading image\nPRE: render task not ready (camera actor not staged)\nPOST:continuous renders, no Finished signal");
1300
1301   // SETUP AN OFFSCREEN RENDER TASK
1302   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1303   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1304   drawTrace.Enable(true);
1305
1306   Actor rootActor = Actor::New();
1307   Stage::GetCurrent().Add( rootActor );
1308
1309   CameraActor offscreenCameraActor = CameraActor::New();
1310   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1311   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1312   Integration::ResourceId imageRequestId = imageRequest->GetId();
1313   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1314   Stage::GetCurrent().Add(secondRootActor);
1315
1316   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1317   bool finished = false;
1318   RenderTaskFinished renderTaskFinished( finished );
1319   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1320   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1321   application.SendNotification();
1322
1323   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1324   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1325   application.GetPlatform().ClearReadyResources();
1326   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, false ) );
1327
1328   // ADD CAMERA ACTOR TO STAGE - expect continuous renders to start, no finished signal
1329   Stage::GetCurrent().Add( offscreenCameraActor );
1330   application.SendNotification();
1331
1332   // CONTINUE PROCESS/RENDER                 Input,    Expected  Input,    Expected
1333   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1334   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
1335   END_TEST;
1336 }
1337
1338
1339 int UtcDaliRenderTaskContinuous04(void)
1340 {
1341   TestApplication application;
1342
1343   tet_infoline("Testing RenderTask Render Continuous using loading image\nPRE: Resource not ready\nPOST:continuous renders, no Finished signal");
1344
1345   // SETUP AN OFFSCREEN RENDER TASK
1346   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1347   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1348   drawTrace.Enable(true);
1349
1350   Actor rootActor = Actor::New();
1351   Stage::GetCurrent().Add( rootActor );
1352
1353   CameraActor offscreenCameraActor = CameraActor::New();
1354   Stage::GetCurrent().Add( offscreenCameraActor );
1355   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1356   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1357   Integration::ResourceId imageRequestId = imageRequest->GetId();
1358   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1359   Stage::GetCurrent().Add(secondRootActor);
1360
1361   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1362   bool finished = false;
1363   RenderTaskFinished renderTaskFinished( finished );
1364   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1365   application.SendNotification();
1366
1367   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1368   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1369   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1370
1371   // FINISH RESOURCE LOADING - expect 'continuous' renders to start, no finished signal
1372   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1373   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
1374   END_TEST;
1375 }
1376
1377
1378 int UtcDaliRenderTaskOnce01(void)
1379 {
1380   TestApplication application;
1381
1382   tet_infoline("Testing RenderTask Render Once GlSync, using loading image\nPRE: Resources not ready, Source not visible\nPOST: Finished signal sent once only");
1383
1384   // SETUP AN OFFSCREEN RENDER TASK
1385   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1386   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
1387   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1388   drawTrace.Enable(true);
1389
1390   Actor rootActor = Actor::New();
1391   Stage::GetCurrent().Add( rootActor );
1392
1393   CameraActor offscreenCameraActor = CameraActor::New();
1394   Stage::GetCurrent().Add( offscreenCameraActor );
1395   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1396   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1397   Integration::ResourceId imageRequestId = imageRequest->GetId();
1398   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1399
1400   Stage::GetCurrent().Add(secondRootActor);
1401   secondRootActor.SetVisible(false);
1402
1403   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, true);
1404   bool finished = false;
1405   RenderTaskFinished renderTaskFinished( finished );
1406   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1407   application.SendNotification();
1408
1409   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1410   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1411   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1412
1413   // MAKE SOURCE VISIBLE
1414   secondRootActor.SetVisible(true);
1415   application.SendNotification();
1416   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1417   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1418
1419   // FINISH RESOURCE LOADING - expect no rendering yet
1420   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1421   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1422   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
1423   DALI_TEST_CHECK( lastSyncObj != NULL );
1424
1425   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1426   application.GetPlatform().ClearReadyResources();
1427   sync.SetObjectSynced( lastSyncObj, true );
1428   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,   finished, false, true  ) );
1429   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
1430   END_TEST;
1431 }
1432
1433 int UtcDaliRenderTaskOnce02(void)
1434 {
1435   TestApplication application;
1436
1437   tet_infoline("Testing RenderTask Render Once GlSync, using loading image. Switch from render always after ready to render once\n"
1438                "PRE: Render task ready, Image not loaded\n"
1439                "POST: Finished signal sent only once");
1440
1441   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
1442   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1443   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
1444   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1445   drawTrace.Enable(true);
1446
1447   Actor rootActor = Actor::New();
1448   Stage::GetCurrent().Add( rootActor );
1449
1450   CameraActor offscreenCameraActor = CameraActor::New();
1451   Stage::GetCurrent().Add( offscreenCameraActor );
1452   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1453   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1454   Integration::ResourceId imageRequestId = imageRequest->GetId();
1455   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1456   Stage::GetCurrent().Add(secondRootActor);
1457
1458   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1459   bool finished = false;
1460   RenderTaskFinished renderTaskFinished( finished );
1461   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1462   application.SendNotification();
1463
1464   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1465   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1466   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1467
1468   // FINISH RESOURCE LOADING
1469   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1470   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
1471   application.GetPlatform().ClearReadyResources();
1472   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
1473
1474   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
1475   application.SendNotification(); //         Input,    Expected  Input,    Expected
1476   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1477   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
1478   DALI_TEST_CHECK( lastSyncObj != NULL );
1479
1480   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1481   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1482   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1483   sync.SetObjectSynced( lastSyncObj, true );
1484   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true  ) );
1485   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
1486
1487   END_TEST;
1488 }
1489
1490
1491 int UtcDaliRenderTaskOnce03(void)
1492 {
1493   TestApplication application;
1494
1495   tet_infoline("Testing RenderTask Render Once GlSync\n"
1496                "Switch from Render always after ready to render once with resources unready\n"
1497                "PRE: Everything ready to render\n"
1498                "POST: Finished signal sent once");
1499
1500   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
1501   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1502   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
1503   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1504   drawTrace.Enable(true);
1505
1506   Actor rootActor = Actor::New();
1507   Stage::GetCurrent().Add( rootActor );
1508
1509   CameraActor offscreenCameraActor = CameraActor::New();
1510   Stage::GetCurrent().Add( offscreenCameraActor );
1511   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1512   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1513   Integration::ResourceId imageRequestId = imageRequest->GetId();
1514   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1515   Stage::GetCurrent().Add(secondRootActor);
1516
1517   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1518   bool finished = false;
1519   RenderTaskFinished renderTaskFinished( finished );
1520   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1521   application.SendNotification();
1522
1523   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1524   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1525   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1526
1527   // CHANGE TO RENDER ONCE
1528   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
1529   application.SendNotification(); //         Input,    Expected  Input,    Expected
1530   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1531   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1532
1533   // FINISH RESOURCE LOADING
1534   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1535   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1536   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
1537   DALI_TEST_CHECK( lastSyncObj != NULL );
1538   application.GetPlatform().ClearReadyResources();
1539
1540   sync.SetObjectSynced( lastSyncObj, true );
1541   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true  ) );
1542   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
1543
1544   END_TEST;
1545 }
1546
1547 #if 0
1548 //int UtcDaliRenderTaskOnce04(void)
1549 {
1550   TestApplication application;
1551
1552   tet_infoline("Testing RenderTask Render Once GlSync\n"
1553                "During RenderOnce, make ready resources unready before sending first finished signal\n"
1554                "PRE: Everything ready.\n"
1555                "POST: Finished signal sent only once");
1556
1557   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
1558   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1559   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
1560   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1561   drawTrace.Enable(true);
1562
1563   Actor rootActor = Actor::New();
1564   Stage::GetCurrent().Add( rootActor );
1565
1566   CameraActor offscreenCameraActor = CameraActor::New();
1567   Stage::GetCurrent().Add( offscreenCameraActor );
1568   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1569   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1570   Integration::ResourceId imageRequestId = imageRequest->GetId();
1571   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1572   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1573   application.Render();
1574
1575   Stage::GetCurrent().Add(secondRootActor);
1576   application.GetPlatform().ClearReadyResources();
1577
1578   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1579   bool finished = false;
1580   RenderTaskFinished renderTaskFinished( finished );
1581   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1582   application.SendNotification();
1583
1584   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1585   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1586   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1587
1588   // CHANGE TO RENDER ONCE, RESOURCES BECOME NOT READY
1589   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
1590
1591   // Doesn't work...
1592   ReloadImage(application, secondRootActor.GetImage());
1593   application.SendNotification(); //         Input,    Expected  Input,    Expected
1594
1595   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1596   DALI_TEST_EQUALS( secondRootActor.GetImage().GetLoadingState(), Dali::ResourceLoading, TEST_LOCATION);
1597   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1598
1599   // FINISH RESOURCE LOADING
1600   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1601   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1602   application.GetPlatform().ClearReadyResources();
1603   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
1604   DALI_TEST_CHECK( lastSyncObj != NULL );
1605
1606   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1607   sync.SetObjectSynced( lastSyncObj, true );
1608   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true  ) );
1609   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, true  ) );
1610
1611   // Finished rendering - expect no more renders, no more signals:
1612   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1613   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1614   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1615   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1616   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1617   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1618   END_TEST;
1619 }
1620 #endif
1621
1622 int UtcDaliRenderTaskOnce05(void)
1623 {
1624   TestApplication application;
1625
1626   tet_infoline("Testing RenderTask Render Once GLSync\n"
1627                "Render once, Second call to SetRefreshRate(ONCE) triggers only one more finished signal\n"
1628                "PRE: Everything ready\n"
1629                "POST: exactly 1 finished signal per call to SetRefreshRate(ONCE)");
1630
1631   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
1632   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1633   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
1634   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1635   drawTrace.Enable(true);
1636
1637   Actor rootActor = Actor::New();
1638   Stage::GetCurrent().Add( rootActor );
1639
1640   CameraActor offscreenCameraActor = CameraActor::New();
1641   Stage::GetCurrent().Add( offscreenCameraActor );
1642   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1643   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1644   Integration::ResourceId imageRequestId = imageRequest->GetId();
1645   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1646   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1647   application.Render();
1648   application.GetPlatform().ClearReadyResources();
1649
1650   Stage::GetCurrent().Add(secondRootActor);
1651
1652   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1653   bool finished = false;
1654   RenderTaskFinished renderTaskFinished( finished );
1655   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1656   application.SendNotification();
1657
1658   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1659   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1660   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
1661
1662   // CHANGE TO RENDER ONCE,
1663   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
1664   application.SendNotification();
1665   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1666   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
1667   DALI_TEST_CHECK( lastSyncObj != NULL );
1668
1669   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1670   sync.SetObjectSynced( lastSyncObj, true );
1671   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1672   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true,  false  ) );
1673
1674   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
1675   application.SendNotification();
1676   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1677   lastSyncObj = sync.GetLastSyncObject();
1678   DALI_TEST_CHECK( lastSyncObj != NULL );
1679
1680   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1681   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1682   sync.SetObjectSynced( lastSyncObj, true );
1683   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1684   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
1685   END_TEST;
1686 }
1687
1688 int UtcDaliRenderTaskOnce06(void)
1689 {
1690   TestApplication application;
1691
1692   tet_infoline("Testing RenderTask Render Once GLSync\n"
1693                "Render once, Call to SetRefreshRate(ONCE) in Finished signal callback triggers "
1694                "another render & another finished signal\n"
1695                "PRE: Everything ready\n"
1696                "POST: exactly 1 finished signal per call to SetRefreshRate(ONCE)");
1697
1698
1699   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
1700   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1701   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
1702   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1703   drawTrace.Enable(true);
1704
1705   Actor rootActor = Actor::New();
1706   Stage::GetCurrent().Add( rootActor );
1707
1708   CameraActor offscreenCameraActor = CameraActor::New();
1709   Stage::GetCurrent().Add( offscreenCameraActor );
1710   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1711   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1712   Integration::ResourceId imageRequestId = imageRequest->GetId();
1713   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1714   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1715   application.Render();
1716   application.GetPlatform().ClearReadyResources();
1717
1718   Stage::GetCurrent().Add(secondRootActor);
1719
1720   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1721   bool finished = false;
1722
1723   ConnectionTracker connectionTracker;
1724   RenderTaskFinishedRenderAgain renderTaskFinishedRenderAgain( finished );
1725   newTask.FinishedSignal().Connect( &connectionTracker, renderTaskFinishedRenderAgain );
1726
1727   application.SendNotification();
1728
1729   // Expect 2 frames to be drawn.
1730   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1731   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1732   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
1733   DALI_TEST_CHECK( lastSyncObj == NULL );
1734   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
1735
1736   // CHANGE TO RENDER ONCE,
1737   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
1738   application.SendNotification();
1739   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1740   lastSyncObj = sync.GetLastSyncObject();
1741   DALI_TEST_CHECK( lastSyncObj != NULL );
1742
1743   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1744   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1745
1746   sync.SetObjectSynced( lastSyncObj, true );
1747   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1748   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
1749   application.SendNotification();
1750
1751   // Expect SetRefreshRate to have been called again
1752   // Prevent next finished signal calling refresh once again
1753   RenderTaskFinished renderTaskFinished( finished );
1754   connectionTracker.DisconnectAll();
1755   newTask.FinishedSignal().Connect( &connectionTracker, renderTaskFinished );
1756   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1757   lastSyncObj = sync.GetLastSyncObject();
1758   DALI_TEST_CHECK( lastSyncObj != NULL );
1759
1760   sync.SetObjectSynced( lastSyncObj, true );
1761   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1762   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
1763   END_TEST;
1764 }
1765
1766
1767 int UtcDaliRenderTaskOnce07(void)
1768 {
1769   TestApplication application;
1770
1771   tet_infoline("Testing RenderTask Render Once GlSync\n"
1772                "SetRefreshRate(ONCE) again before first finished signal has been sent.\n"
1773                "PRE: resources ready\n"
1774                "POST: Only 1 finished signal sent.");
1775
1776   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
1777   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1778   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
1779   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1780   drawTrace.Enable(true);
1781
1782   Actor rootActor = Actor::New();
1783   Stage::GetCurrent().Add( rootActor );
1784
1785   CameraActor offscreenCameraActor = CameraActor::New();
1786   Stage::GetCurrent().Add( offscreenCameraActor );
1787   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1788   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1789   Integration::ResourceId imageRequestId = imageRequest->GetId();
1790   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1791   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1792   application.Render();
1793   application.GetPlatform().ClearReadyResources();
1794
1795   Stage::GetCurrent().Add(secondRootActor);
1796
1797   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1798   bool finished = false;
1799   RenderTaskFinished renderTaskFinished( finished );
1800   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1801   application.SendNotification();
1802
1803   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1804   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1805   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
1806
1807   // CHANGE TO RENDER ONCE,
1808   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
1809   application.SendNotification();
1810   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1811   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1812   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1813
1814   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
1815   application.SendNotification();
1816   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1817   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
1818   DALI_TEST_CHECK( lastSyncObj != NULL );
1819
1820   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1821   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1822   sync.SetObjectSynced( lastSyncObj, true );
1823   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1824   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
1825
1826   END_TEST;
1827 }
1828
1829
1830
1831 int UtcDaliRenderTaskOnce08(void)
1832 {
1833   TestApplication application;
1834
1835   tet_infoline("Testing RenderTask Render Once GlSync\n"
1836                "SetRefreshRate(ONCE), resource load failed completes render task.\n"
1837                "PRE: resources not ready\n"
1838                "POST: Only 1 finished signal sent.");
1839
1840   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
1841   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1842   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
1843   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1844   drawTrace.Enable(true);
1845
1846   Actor rootActor = Actor::New();
1847   Stage::GetCurrent().Add( rootActor );
1848
1849   CameraActor offscreenCameraActor = CameraActor::New();
1850   Stage::GetCurrent().Add( offscreenCameraActor );
1851   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1852   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1853   Integration::ResourceId imageRequestId = imageRequest->GetId();
1854   Stage::GetCurrent().Add(secondRootActor);
1855
1856   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1857   bool finished = false;
1858   RenderTaskFinished renderTaskFinished( finished );
1859   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1860   application.SendNotification();
1861
1862   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1863   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1864   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1865
1866   // CHANGE TO RENDER ONCE,
1867   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
1868   application.SendNotification();
1869   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1870   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1871   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
1872
1873   tet_printf("  FailImageLoad\n");
1874
1875   FailImageLoad(application, imageRequestId); // Need to run Update again for this to complete
1876   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) ); // nothing to draw
1877   application.SendNotification();
1878
1879   // Drawing empty framebuffer, so will still get a GL sync
1880   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
1881   DALI_TEST_CHECK( lastSyncObj != NULL );
1882
1883   // Expect finished signal, as all resources are complete
1884   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,   finished, true, false ) );
1885
1886   END_TEST;
1887 }
1888
1889
1890
1891 int UtcDaliRenderTaskOnceNoSync01(void)
1892 {
1893   TestApplication application;
1894
1895   tet_infoline("Testing RenderTask Render Once, using loading image\nPRE: Resources not ready, Source not visible\nPOST: Finished signal sent once only");
1896
1897   // SETUP AN OFFSCREEN RENDER TASK
1898   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1899   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1900   drawTrace.Enable(true);
1901
1902   Actor rootActor = Actor::New();
1903   Stage::GetCurrent().Add( rootActor );
1904
1905   CameraActor offscreenCameraActor = CameraActor::New();
1906   Stage::GetCurrent().Add( offscreenCameraActor );
1907   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1908   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1909   Integration::ResourceId imageRequestId = imageRequest->GetId();
1910   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1911
1912   Stage::GetCurrent().Add(secondRootActor);
1913   secondRootActor.SetVisible(false);
1914
1915   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, false);
1916   bool finished = false;
1917   RenderTaskFinished renderTaskFinished( finished );
1918   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1919   application.SendNotification();
1920
1921   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1922   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1923   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1924
1925   // MAKE SOURCE VISIBLE
1926   secondRootActor.SetVisible(true);
1927   application.SendNotification();
1928   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1929   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1930
1931   // FINISH RESOURCE LOADING - expect immediate rendering yet
1932   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1933   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1934   application.GetPlatform().ClearReadyResources();
1935   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false ) );
1936   END_TEST;
1937 }
1938
1939 int UtcDaliRenderTaskOnceNoSync02(void)
1940 {
1941   TestApplication application;
1942
1943   tet_infoline("Testing RenderTask Render Once, using loading image. Switch from render always after ready to render once\n"
1944                "PRE: Render task ready, Image not loaded\n"
1945                "POST: Finished signal sent only once");
1946
1947   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
1948   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1949   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1950   drawTrace.Enable(true);
1951
1952   Actor rootActor = Actor::New();
1953   Stage::GetCurrent().Add( rootActor );
1954
1955   CameraActor offscreenCameraActor = CameraActor::New();
1956   Stage::GetCurrent().Add( offscreenCameraActor );
1957   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1958   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1959   Integration::ResourceId imageRequestId = imageRequest->GetId();
1960   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1961   Stage::GetCurrent().Add(secondRootActor);
1962
1963   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
1964   bool finished = false;
1965   RenderTaskFinished renderTaskFinished( finished );
1966   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1967   application.SendNotification();
1968
1969   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1970   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1971   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1972
1973   // FINISH RESOURCE LOADING
1974   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1975   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
1976   application.GetPlatform().ClearReadyResources();
1977
1978   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
1979   application.SendNotification(); //         Input,    Expected  Input,    Expected
1980   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
1981   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
1982   END_TEST;
1983 }
1984
1985
1986 int UtcDaliRenderTaskOnceNoSync03(void)
1987 {
1988   TestApplication application;
1989
1990   tet_infoline("Testing RenderTask Render Once\n"
1991                "Switch from Render always after ready to render once with resources unready\n"
1992                "PRE: Everything ready to render\n"
1993                "POST: Finished signal sent once");
1994
1995   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
1996   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1997   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1998   drawTrace.Enable(true);
1999
2000   Actor rootActor = Actor::New();
2001   Stage::GetCurrent().Add( rootActor );
2002
2003   CameraActor offscreenCameraActor = CameraActor::New();
2004   Stage::GetCurrent().Add( offscreenCameraActor );
2005   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
2006   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
2007   Integration::ResourceId imageRequestId = imageRequest->GetId();
2008   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
2009   Stage::GetCurrent().Add(secondRootActor);
2010
2011   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
2012   bool finished = false;
2013   RenderTaskFinished renderTaskFinished( finished );
2014   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2015   application.SendNotification();
2016
2017   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2018   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2019   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2020
2021   // CHANGE TO RENDER ONCE
2022   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2023   application.SendNotification(); //         Input,    Expected  Input,    Expected
2024   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2025   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2026
2027   // FINISH RESOURCE LOADING
2028   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2029   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2030   application.GetPlatform().ClearReadyResources();
2031   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
2032   END_TEST;
2033 }
2034
2035 #if 0
2036 //int UtcDaliRenderTaskOnceNoSync04(void)
2037 {
2038   TestApplication application;
2039
2040   tet_infoline("Testing RenderTask Render Once\n"
2041                "During RenderOnce, make ready resources unready before sending first finished signal\n"
2042                "PRE: Everything ready.\n"
2043                "POST: Finished signal sent only once");
2044
2045   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2046   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2047   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2048   drawTrace.Enable(true);
2049
2050   Actor rootActor = Actor::New();
2051   Stage::GetCurrent().Add( rootActor );
2052
2053   CameraActor offscreenCameraActor = CameraActor::New();
2054   Stage::GetCurrent().Add( offscreenCameraActor );
2055   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
2056   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
2057   Integration::ResourceId imageRequestId = imageRequest->GetId();
2058   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
2059   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2060   application.Render();
2061   application.GetPlatform().ClearReadyResources();
2062
2063   Stage::GetCurrent().Add(secondRootActor);
2064
2065   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
2066   bool finished = false;
2067   RenderTaskFinished renderTaskFinished( finished );
2068   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2069   application.SendNotification();
2070
2071   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2072   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2073   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
2074
2075   // CHANGE TO RENDER ONCE, RESOURCES BECOME NOT READY
2076   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2077
2078   // Doesn't work...
2079   ReloadImage(application, secondRootActor.GetImage());
2080   application.SendNotification(); //         Input,    Expected  Input,    Expected
2081
2082   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2083   DALI_TEST_EQUALS( secondRootActor.GetImage().GetLoadingState(), Dali::ResourceLoading, TEST_LOCATION);
2084   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2085
2086   // FINISH RESOURCE LOADING
2087   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2088   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, true, true ) );
2089   application.GetPlatform().ClearReadyResources();
2090   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2091   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true  ) );
2092   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2093   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2094   END_TEST;
2095 }
2096 #endif
2097
2098 int UtcDaliRenderTaskOnceNoSync05(void)
2099 {
2100   TestApplication application;
2101
2102   tet_infoline("Testing RenderTask Render Once\n"
2103                "Render once, Second call to SetRefreshRate(ONCE) triggers only one more finished signal\n"
2104                "PRE: Everything ready\n"
2105                "POST: exactly 1 finished signal per call to SetRefreshRate(ONCE)");
2106
2107   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2108   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2109   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2110   drawTrace.Enable(true);
2111
2112   Actor rootActor = Actor::New();
2113   Stage::GetCurrent().Add( rootActor );
2114
2115   CameraActor offscreenCameraActor = CameraActor::New();
2116   Stage::GetCurrent().Add( offscreenCameraActor );
2117   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
2118   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
2119   Integration::ResourceId imageRequestId = imageRequest->GetId();
2120   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
2121   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2122   application.Render();
2123   application.GetPlatform().ClearReadyResources();
2124
2125   Stage::GetCurrent().Add(secondRootActor);
2126
2127   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
2128   bool finished = false;
2129   RenderTaskFinished renderTaskFinished( finished );
2130   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2131   application.SendNotification();
2132
2133   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2134   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2135   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
2136
2137   // CHANGE TO RENDER ONCE,
2138   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2139   application.SendNotification();
2140   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2141   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true,  false ) );
2142
2143   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2144   application.SendNotification();
2145   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2146   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true,  false ) );
2147   END_TEST;
2148 }
2149
2150 int UtcDaliRenderTaskOnceNoSync06(void)
2151 {
2152   TestApplication application;
2153
2154   tet_infoline("Testing RenderTask Render Once\n"
2155                "Render once, Call to SetRefreshRate(ONCE) in Finished signal callback triggers\n"
2156                "another render & another finished signal\n"
2157                "PRE: Everything ready\n"
2158                "POST: exactly 1 finished signal per call to SetRefreshRate(ONCE)");
2159
2160
2161   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2162   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2163   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2164   drawTrace.Enable(true);
2165
2166   Actor rootActor = Actor::New();
2167   Stage::GetCurrent().Add( rootActor );
2168
2169   CameraActor offscreenCameraActor = CameraActor::New();
2170   Stage::GetCurrent().Add( offscreenCameraActor );
2171   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
2172   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
2173   Integration::ResourceId imageRequestId = imageRequest->GetId();
2174   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
2175   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2176   application.Render();
2177   application.GetPlatform().ClearReadyResources();
2178
2179   Stage::GetCurrent().Add(secondRootActor);
2180
2181   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
2182   bool finished = false;
2183
2184   ConnectionTracker connectionTracker;
2185   RenderTaskFinishedRenderAgain renderTaskFinishedRenderAgain( finished );
2186   newTask.FinishedSignal().Connect( &connectionTracker, renderTaskFinishedRenderAgain );
2187
2188   application.SendNotification();
2189
2190   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2191   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2192   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
2193
2194   // CHANGE TO RENDER ONCE,
2195   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2196   application.SendNotification();
2197   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2198   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true,  false ) );
2199
2200   // Expect SetRefreshRate to have been called again
2201   // Prevent next finished signal calling refresh once again
2202   RenderTaskFinished renderTaskFinished( finished );
2203   connectionTracker.DisconnectAll();
2204   newTask.FinishedSignal().Connect( &connectionTracker, renderTaskFinished );
2205
2206   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2207   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true,  false ) );
2208   END_TEST;
2209 }
2210
2211
2212 int UtcDaliRenderTaskOnceNoSync07(void)
2213 {
2214   TestApplication application;
2215
2216   tet_infoline("Testing RenderTask Render Once\n"
2217                "SetRefreshRate(ONCE) again before first finished signal has been sent.\n"
2218                "PRE: resources ready\n"
2219                "POST: Only 1 finished signal sent.");
2220
2221   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2222   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2223   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2224   drawTrace.Enable(true);
2225
2226   Actor rootActor = Actor::New();
2227   Stage::GetCurrent().Add( rootActor );
2228
2229   CameraActor offscreenCameraActor = CameraActor::New();
2230   Stage::GetCurrent().Add( offscreenCameraActor );
2231   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
2232   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
2233   Integration::ResourceId imageRequestId = imageRequest->GetId();
2234   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
2235   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2236   application.Render();
2237   application.GetPlatform().ClearReadyResources();
2238
2239   Stage::GetCurrent().Add(secondRootActor);
2240
2241   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
2242   bool finished = false;
2243   RenderTaskFinished renderTaskFinished( finished );
2244   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2245   application.SendNotification();
2246
2247   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2248   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2249   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
2250
2251   // CHANGE TO RENDER ONCE,
2252   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2253   application.SendNotification();
2254   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2255   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true,  false ) );
2256
2257   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2258   application.SendNotification();
2259   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2260   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true,  false ) );
2261   END_TEST;
2262 }
2263
2264 int UtcDaliRenderTaskOnceNoSync08(void)
2265 {
2266   TestApplication application;
2267
2268   tet_infoline("Testing RenderTask Render Once\n"
2269                "SetRefreshRate(ONCE), resource load failed, completes render task.\n"
2270                "PRE: resources not ready\n"
2271                "POST: Only 1 finished signal sent.");
2272
2273   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2274   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2275   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2276   drawTrace.Enable(true);
2277
2278   Actor rootActor = Actor::New();
2279   Stage::GetCurrent().Add( rootActor );
2280
2281   CameraActor offscreenCameraActor = CameraActor::New();
2282   Stage::GetCurrent().Add( offscreenCameraActor );
2283   ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
2284   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
2285   Integration::ResourceId imageRequestId = imageRequest->GetId();
2286   Stage::GetCurrent().Add(secondRootActor);
2287
2288   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
2289   bool finished = false;
2290   RenderTaskFinished renderTaskFinished( finished );
2291   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2292   application.SendNotification();
2293
2294   // START PROCESS/RENDER                    Input,     Expected  Input,    Expected
2295   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2296   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2297
2298   // CHANGE TO RENDER ONCE,
2299   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2300   application.SendNotification();
2301   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2302   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2303   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2304
2305   FailImageLoad(application, imageRequestId); // Need to run Update again for this to complete
2306   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) ); // nothing to draw
2307   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, true,  false  ) );
2308
2309   END_TEST;
2310 }
2311
2312
2313
2314 int UtcDaliRenderTaskOnceChain01(void)
2315 {
2316   TestApplication application;
2317
2318   tet_infoline("Testing RenderTask Render Once Chained render tasks\n"
2319                "SetRefreshRate(ONCE), resource load completes, both render tasks render.\n"
2320                "PRE: resources not ready\n"
2321                "POST: 2 finished signals sent.");
2322
2323   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2324   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2325   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2326   drawTrace.Enable(true);
2327
2328   Actor defaultRootActor = Actor::New(); // Root for default RT
2329   Stage::GetCurrent().Add( defaultRootActor );
2330
2331   CameraActor offscreenCameraActor = CameraActor::New();
2332   Stage::GetCurrent().Add( offscreenCameraActor );
2333   ImageActor firstRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
2334   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
2335   Integration::ResourceId imageRequestId = imageRequest->GetId();
2336   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
2337   Stage::GetCurrent().Add(firstRootActor);
2338
2339   // first render task
2340   RenderTask firstTask = CreateRenderTask(application, offscreenCameraActor, defaultRootActor, firstRootActor, RenderTask::REFRESH_ONCE, false);
2341   bool firstFinished = false;
2342   RenderTaskFinished renderTask1Finished( firstFinished );
2343   firstTask.FinishedSignal().Connect( &application, renderTask1Finished );
2344
2345   // Second render task
2346   FrameBufferImage fbo = firstTask.GetTargetFrameBuffer();
2347   ImageActor secondRootActor = ImageActor::New( fbo );
2348   Stage::GetCurrent().Add(secondRootActor);
2349   RenderTask secondTask = CreateRenderTask(application, offscreenCameraActor, defaultRootActor, secondRootActor, RenderTask::REFRESH_ONCE, false);
2350   bool secondFinished = false;
2351   RenderTaskFinished renderTask2Finished( secondFinished );
2352   secondTask.FinishedSignal().Connect( &application, renderTask2Finished );
2353
2354   application.SendNotification();
2355
2356   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2357   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,  firstFinished, false, true ) );
2358   DALI_TEST_CHECK( secondFinished == false );
2359   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,  firstFinished, false, true ) );
2360   DALI_TEST_CHECK( secondFinished == false );
2361
2362   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2363   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,  firstFinished, false, true ) );
2364   DALI_TEST_CHECK( secondFinished == false );
2365   application.GetPlatform().ClearReadyResources();
2366
2367   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,  firstFinished, true,  false ) );
2368   DALI_TEST_CHECK( secondFinished == true );
2369
2370   END_TEST;
2371 }
2372
2373 int UtcDaliRenderTaskProperties(void)
2374 {
2375   TestApplication application;
2376
2377   RenderTask task = Stage::GetCurrent().GetRenderTaskList().CreateTask();
2378
2379   Property::IndexContainer indices;
2380   task.GetPropertyIndices( indices );
2381   DALI_TEST_CHECK( ! indices.empty() );
2382   DALI_TEST_EQUALS( indices.size(), task.GetPropertyCount(), TEST_LOCATION );
2383   END_TEST;
2384 }
2385
2386 int UtcDaliRenderTaskSetScreenToFrameBufferMappingActor(void)
2387 {
2388   TestApplication application;
2389   tet_infoline("Testing RenderTask::SetScreenToFrameBufferMappingActor ");
2390
2391   Stage stage = Stage::GetCurrent();
2392   Size stageSize = stage.GetSize();
2393   Actor mappingActor = Actor::New();
2394   Vector2 scale( 0.6f, 0.75f);
2395   Vector2 offset( stageSize.x*0.1f, stageSize.y*0.15f);
2396   mappingActor.SetSize( stageSize * scale );
2397   mappingActor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
2398   mappingActor.SetPosition( offset.x, offset.y );
2399   stage.Add( mappingActor );
2400
2401   Actor offscreenActor = Actor::New();
2402   offscreenActor.SetSize( stageSize );
2403   offscreenActor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
2404   stage.Add( offscreenActor );
2405
2406   RenderTaskList taskList = stage.GetRenderTaskList();
2407   RenderTask renderTask = taskList.CreateTask();
2408   FrameBufferImage frameBufferImage =  FrameBufferImage::New(stageSize.width*scale.x, stageSize.height*scale.y, Pixel::A8, Image::NEVER);
2409   renderTask.SetSourceActor( offscreenActor );
2410   renderTask.SetExclusive( true );
2411   renderTask.SetInputEnabled( true );
2412   renderTask.SetTargetFrameBuffer( frameBufferImage );
2413   renderTask.SetRefreshRate( RenderTask::REFRESH_ONCE );
2414   renderTask.SetScreenToFrameBufferMappingActor( mappingActor );
2415   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2416
2417   // Render and notify
2418   application.SendNotification();
2419   application.Render();
2420   application.Render();
2421   application.SendNotification();
2422
2423   Vector2 screenCoordinates( stageSize.x * 0.05f, stageSize.y * 0.05f );
2424   Dali::HitTestAlgorithm::Results results;
2425   DALI_TEST_CHECK( !results.actor );
2426   DALI_TEST_EQUALS( Vector2::ZERO, results.actorCoordinates, 0.1f, TEST_LOCATION );
2427   // miss expected, results not changed
2428   DALI_TEST_CHECK( false == Dali::HitTestAlgorithm::HitTest( renderTask, screenCoordinates, results, IsActorHittableFunction ) );
2429   DALI_TEST_CHECK( !results.actor );
2430   DALI_TEST_EQUALS( Vector2::ZERO, results.actorCoordinates, 0.1f, TEST_LOCATION );
2431
2432   screenCoordinates.x = stageSize.x * 0.265f;
2433   screenCoordinates.y = stageSize.y * 0.33f;
2434   results.actor = Actor();
2435   results.actorCoordinates = Vector2::ZERO;
2436   // hit expected, results changed
2437   DALI_TEST_CHECK( true == Dali::HitTestAlgorithm::HitTest( renderTask, screenCoordinates, results, IsActorHittableFunction ) );
2438   DALI_TEST_CHECK( results.actor  == offscreenActor );
2439   DALI_TEST_EQUALS( (screenCoordinates-offset)/scale , results.actorCoordinates, 0.1f, TEST_LOCATION );
2440
2441   screenCoordinates.x = stageSize.x * 0.435f;
2442   screenCoordinates.y = stageSize.y * 0.52f;
2443   // hit expected, results changed
2444   DALI_TEST_CHECK( true == Dali::HitTestAlgorithm::HitTest( renderTask, screenCoordinates, results, IsActorHittableFunction ) );
2445   DALI_TEST_CHECK( results.actor  == offscreenActor );
2446   const Vector2 expectedCoordinates = (screenCoordinates-offset)/scale;
2447   DALI_TEST_EQUALS( expectedCoordinates , results.actorCoordinates, 0.1f, TEST_LOCATION );
2448
2449   screenCoordinates.x = stageSize.x * 0.65f;
2450   screenCoordinates.y = stageSize.y * 0.95f;
2451   // miss expected, results not changed
2452   DALI_TEST_CHECK( false == Dali::HitTestAlgorithm::HitTest( renderTask, screenCoordinates, results, IsActorHittableFunction ) );
2453   DALI_TEST_CHECK( results.actor  == offscreenActor );
2454   DALI_TEST_EQUALS( expectedCoordinates , results.actorCoordinates, 0.1f, TEST_LOCATION );
2455   END_TEST;
2456 }