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