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