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/devel-api/events/hit-test-algorithm.h>
  23 #include <dali-test-suite-utils.h>
  24 #include <dali/integration-api/debug.h>
  25 #include <test-native-image.h>
  26
  27 #include <mesh-builder.h>
  28
  29 #define BOOLSTR(x) ((x)?"T":"F")
  30
  31
  32 using namespace Dali;
  33
  34 void utc_dali_render_task_startup(void)
  35 {
  36   test_return_value = TET_UNDEF;
  37 }
  38
  39 void utc_dali_render_task_cleanup(void)
  40 {
  41   test_return_value = TET_PASS;
  42 }
  43
  44 /**
  45  * APIs:
  46  *
  47  * Constructor, Destructor, DownCast, New, copy constructor, assignment operator
  48  *
  49  * SetSourceActor                      2+ve, 1-ve
  50  * GetSourceActor                      1+ve, 1-ve
  51  * SetExclusive                        2+ve, 0-ve
  52  * IsExclusive                         2+ve, 0-ve
  53  * SetInputEnabled                     1+ve, 0-ve
  54  * GetInputEnabled                     1+ve, 0-ve
  55  * SetCameraActor                      1+ve, 1-ve
  56  * GetCameraActor                      1+ve, 1-ve
  57  * SetTargetFrameBuffer                1+ve, 1-ve
  58  * GetTargetFrameBuffer                1+ve, 1-ve
  59  * SetScreenToFrameBufferFunction      1+ve, 1-ve
  60  * GetScreenToFrameBufferFunction      1+ve, 1-ve
  61  * SetScreenToFrameBufferMappingActor  1+ve, 1-ve
  62  * GetScreenToFrameBufferMappingActor  1+ve, 1-ve
  63  * SetViewportPosition                 1+ve
  64  * GetCurrentViewportPosition          1+ve
  65  * SetViewportSize                     1+ve
  66  * GetCurrentViewportSize              1+ve
  67  * SetViewport                         2+ve, 1-ve
  68  * GetViewport                         2+ve, 1-ve
  69  * SetClearColor                       1+ve, 1-ve
  70  * GetClearColor                       1+ve, 1-ve
  71  * SetClearEnabled                     1+ve, 1-ve
  72  * GetClearEnabled                     1+ve, 1-ve
  73  * SetCullMode
  74  * GetCullMode
  75  * SetRefreshRate                      Many
  76  * GetRefreshRate                      1+ve
  77  * FinishedSignal                      1+ve
  78  */
  79
  80 namespace // unnamed namespace
  81 {
  82
  83 const int RENDER_FRAME_INTERVAL = 16;                           ///< Duration of each frame in ms. (at approx 60FPS)
  84
  85 /*
  86  * Simulate time passed by.
  87  *
  88  * @note this will always process at least 1 frame (1/60 sec)
  89  *
  90  * @param application Test application instance
  91  * @param duration Time to pass in milliseconds.
  92  * @return The actual time passed in milliseconds
  93  */
  94 int Wait(TestApplication& application, int duration = 0)
  95 {
  96   int time = 0;
  97
  98   for(int i = 0; i <= ( duration / RENDER_FRAME_INTERVAL); i++)
  99   {
 100     application.SendNotification();
 101     application.Render(RENDER_FRAME_INTERVAL);
 102     time += RENDER_FRAME_INTERVAL;
 103   }
 104
 105   return time;
 106 }
 107
 108 struct RenderTaskFinished
 109 {
 110   RenderTaskFinished( bool& finished )
 111   : finished( finished )
 112   {
 113   }
 114
 115   void operator()( RenderTask& renderTask )
 116   {
 117     finished = true;
 118   }
 119
 120   bool& finished;
 121 };
 122
 123 struct RenderTaskFinishedRemoveSource
 124 {
 125   RenderTaskFinishedRemoveSource( bool& finished )
 126   : finished( finished ),
 127     finishedOnce(false)
 128   {
 129   }
 130
 131   void operator()( RenderTask& renderTask )
 132   {
 133     DALI_TEST_CHECK(finishedOnce == false);
 134     finished = true;
 135     finishedOnce = true;
 136     Actor srcActor = renderTask.GetSourceActor();
 137     UnparentAndReset(srcActor);
 138   }
 139
 140   bool& finished;
 141   bool finishedOnce;
 142 };
 143
 144 struct RenderTaskFinishedRenderAgain
 145 {
 146   RenderTaskFinishedRenderAgain( bool& finished )
 147   : finished( finished ),
 148     finishedOnce(false)
 149   {
 150   }
 151
 152   void operator()( RenderTask& renderTask )
 153   {
 154     DALI_TEST_CHECK(finishedOnce == false);
 155     finished = true;
 156     finishedOnce = true;
 157     renderTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
 158   }
 159
 160   bool& finished;
 161   bool finishedOnce;
 162 };
 163
 164
 165 bool TestScreenToFrameBufferFunction( Vector2& coordinates )
 166 {
 167   coordinates = coordinates + Vector2( 1, 2 );
 168
 169   return true;
 170 }
 171
 172 ImageActor CreateLoadingImageActor(TestApplication& application, std::string filename, ResourceImage::LoadPolicy loadPolicy, Image::ReleasePolicy releasePolicy)
 173 {
 174   Image image = ResourceImage::New(filename, loadPolicy, releasePolicy);
 175   DALI_TEST_CHECK( image );
 176   application.SendNotification();
 177   application.Render(16);
 178   DALI_TEST_CHECK( application.GetPlatform().WasCalled(TestPlatformAbstraction::LoadResourceFunc) );
 179   ImageActor actor = ImageActor::New(image);
 180   actor.SetSize( 80, 80 );
 181   application.SendNotification();
 182   application.Render(16);
 183   return actor;
 184 }
 185
 186 Image CreateLoadingImage(TestApplication& application, std::string filename, ResourceImage::LoadPolicy loadPolicy, Image::ReleasePolicy releasePolicy)
 187 {
 188   Image image = ResourceImage::New(filename, loadPolicy, releasePolicy);
 189   DALI_TEST_CHECK( image );
 190   application.SendNotification();
 191   application.Render(16);
 192   DALI_TEST_CHECK( application.GetPlatform().WasCalled(TestPlatformAbstraction::LoadResourceFunc) );
 193
 194   return image;
 195 }
 196
 197 void CompleteImageLoad(TestApplication& application, Integration::ResourceId resourceId, Integration::ResourceTypeId requestType)
 198 {
 199   std::vector<GLuint> ids;
 200   ids.push_back( 23 );
 201   application.GetGlAbstraction().SetNextTextureIds( ids );
 202
 203   Integration::Bitmap* bitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD );
 204   Integration::ResourcePointer resource(bitmap);
 205   bitmap->GetPackedPixelsProfile()->ReserveBuffer(Pixel::RGBA8888, 80, 80, 80, 80);
 206
 207   application.GetPlatform().SetResourceLoaded(resourceId, requestType, resource);
 208 }
 209
 210 void FailImageLoad(TestApplication& application, Integration::ResourceId resourceId )
 211 {
 212   application.GetPlatform().SetResourceLoadFailed(resourceId, Integration::FailureUnknown);
 213 }
 214
 215 void ReloadImage(TestApplication& application, ResourceImage image)
 216 {
 217   application.GetPlatform().ClearReadyResources();
 218   application.GetPlatform().DiscardRequest();
 219   application.GetPlatform().ResetTrace();
 220   application.GetPlatform().SetClosestImageSize(Vector2(80.0f, 80.0f)); // Ensure reload is called.
 221   image.Reload();
 222 }
 223
 224 RenderTask CreateRenderTask(TestApplication& application,
 225                             CameraActor offscreenCamera,
 226                             Actor rootActor,       // Reset default render task to point at this actor
 227                             Actor secondRootActor, // Source actor
 228                             unsigned int refreshRate,
 229                             bool glSync)
 230 {
 231   // Change main render task to use a different root
 232   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 233   taskList.GetTask(0u).SetSourceActor( rootActor );
 234
 235   FrameBufferImage frameBufferImage;
 236   if( glSync )
 237   {
 238     NativeImageInterfacePtr testNativeImagePtr = TestNativeImage::New(10, 10);
 239     frameBufferImage= FrameBufferImage::New( *(testNativeImagePtr.Get()) );
 240   }
 241   else
 242   {
 243     frameBufferImage = FrameBufferImage::New( 10, 10 );
 244   }
 245
 246   // Don't draw output framebuffer // '
 247
 248   RenderTask newTask = taskList.CreateTask();
 249   newTask.SetCameraActor( offscreenCamera );
 250   newTask.SetSourceActor( secondRootActor );
 251   newTask.SetInputEnabled( false );
 252   newTask.SetClearColor( Vector4( 0.f, 0.f, 0.f, 0.f ) );
 253   newTask.SetClearEnabled( true );
 254   newTask.SetExclusive( true );
 255   newTask.SetRefreshRate( refreshRate );
 256   newTask.SetTargetFrameBuffer( frameBufferImage );
 257   return newTask;
 258 }
 259
 260 bool UpdateRender(TestApplication& application, TraceCallStack& callStack, bool testDrawn, bool& finishedSig, bool testFinished, bool testKeepUpdating )
 261 {
 262   finishedSig = false;
 263   callStack.Reset();
 264   application.Render(16);
 265   application.SendNotification();
 266
 267   bool sigPassed = false;
 268   if( testFinished )
 269   {
 270     sigPassed = finishedSig;
 271   }
 272   else
 273   {
 274     sigPassed = ! finishedSig;
 275   }
 276
 277   bool drawResult = callStack.FindMethod("DrawElements") || callStack.FindMethod("DrawArrays");
 278
 279   bool drawPassed = false;
 280   if( testDrawn )
 281   {
 282     drawPassed = drawResult;
 283   }
 284   else
 285   {
 286     drawPassed = !drawResult;
 287   }
 288
 289   bool keepUpdating = (application.GetUpdateStatus() != 0);
 290   bool keepUpdatingPassed = false;
 291   if( testKeepUpdating )
 292   {
 293     keepUpdatingPassed = keepUpdating;
 294   }
 295   else
 296   {
 297     keepUpdatingPassed = !keepUpdating;
 298   }
 299
 300   bool result = (sigPassed && drawPassed && keepUpdatingPassed);
 301
 302   tet_printf("UpdateRender: Expected: Draw:%s Signal:%s Keep Updating: %s  Actual: Draw:%s  Signal:%s KeepUpdating: %s  %s\n",
 303              BOOLSTR(testDrawn), BOOLSTR(testFinished), BOOLSTR(testKeepUpdating),
 304              BOOLSTR(drawResult), BOOLSTR(finishedSig), BOOLSTR(keepUpdating),
 305              result ? "Passed":"Failed");
 306
 307   return result;
 308 }
 309
 310 // The functor to be used in the hit-test algorithm to check whether the actor is hittable.
 311 bool IsActorHittableFunction(Actor actor, Dali::HitTestAlgorithm::TraverseType type)
 312 {
 313   bool hittable = false;
 314
 315   switch (type)
 316   {
 317     case Dali::HitTestAlgorithm::CHECK_ACTOR:
 318     {
 319       // Check whether the actor is visible and not fully transparent.
 320       if( actor.IsVisible()
 321           && actor.GetCurrentWorldColor().a > 0.01f) // not FULLY_TRANSPARENT
 322       {
 323
 324         hittable = true;
 325       }
 326       break;
 327     }
 328     case Dali::HitTestAlgorithm::DESCEND_ACTOR_TREE:
 329     {
 330       if( actor.IsVisible() ) // Actor is visible, if not visible then none of its children are visible.
 331       {
 332         hittable = true;
 333       }
 334       break;
 335     }
 336     default:
 337     {
 338       break;
 339     }
 340   }
 341
 342   return hittable;
 343 }
 344
 345 } // unnamed namespace
 346
 347
 348 /****************************************************************************************************/
 349 /****************************************************************************************************/
 350 /********************************   TEST CASES BELOW   **********************************************/
 351 /****************************************************************************************************/
 352 /****************************************************************************************************/
 353
 354 int UtcDaliRenderTaskDownCast01(void)
 355 {
 356   TestApplication application;
 357
 358   tet_infoline("Testing RenderTask::DownCast()");
 359
 360   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 361
 362   BaseHandle base = taskList.GetTask( 0u );
 363   DALI_TEST_CHECK( base );
 364
 365   RenderTask task = RenderTask::DownCast( base );
 366   DALI_TEST_CHECK( task );
 367
 368   // Try calling a method
 369   DALI_TEST_CHECK( task.GetSourceActor() );
 370   END_TEST;
 371 }
 372
 373 int UtcDaliRenderTaskDownCast02(void)
 374 {
 375   TestApplication application;
 376
 377   tet_infoline("Testing RenderTask::DownCast()");
 378
 379   Actor actor = Actor::New();
 380
 381   RenderTask task = RenderTask::DownCast( actor );
 382   DALI_TEST_CHECK( ! task );
 383
 384   END_TEST;
 385 }
 386
 387 int UtcDaliRenderTaskSetSourceActorN(void)
 388 {
 389   TestApplication application;
 390   tet_infoline("Testing RenderTask::SetSourceActor() Negative - try with empty actor handle");
 391   Stage stage = Stage::GetCurrent();
 392
 393   Actor srcActor;
 394
 395   RenderTaskList taskList = stage.GetRenderTaskList();
 396   RenderTask renderTask = taskList.CreateTask();
 397   renderTask.SetSourceActor(srcActor);
 398
 399   application.SendNotification();
 400   application.Render();
 401
 402   DALI_TEST_CHECK( ! renderTask.GetSourceActor() );
 403   END_TEST;
 404 }
 405
 406
 407 int UtcDaliRenderTaskSetSourceActorP01(void)
 408 {
 409   TestApplication application;
 410
 411   tet_infoline("Testing RenderTask::SetSourceActor() Positive - check that setting a non-renderable actor stops existing source actor being rendered ");
 412
 413   Stage stage = Stage::GetCurrent();
 414
 415   const std::vector<GLuint>& boundTextures = application.GetGlAbstraction().GetBoundTextures( GL_TEXTURE0 );
 416
 417   RenderTaskList taskList = stage.GetRenderTaskList();
 418
 419   RenderTask task = taskList.GetTask( 0u );
 420
 421   Actor actor = task.GetSourceActor();
 422   DALI_TEST_CHECK( actor );
 423
 424   std::vector<GLuint> ids;
 425   ids.push_back( 7 );
 426   application.GetGlAbstraction().SetNextTextureIds( ids );
 427
 428   BufferImage img = BufferImage::New( 1,1 );
 429   ImageActor newActor = ImageActor::New( img );
 430   newActor.SetSize(1,1);
 431   stage.Add( newActor );
 432
 433   Actor nonRenderableActor = Actor::New();
 434   stage.Add( nonRenderableActor );
 435
 436   // Stop the newActor from being rendered by changing the source actor
 437   DALI_TEST_CHECK( nonRenderableActor );
 438   task.SetSourceActor( nonRenderableActor );
 439   DALI_TEST_CHECK( task.GetSourceActor() != actor );
 440   DALI_TEST_CHECK( task.GetSourceActor() == nonRenderableActor );
 441
 442   // Update & Render nothing!
 443   application.GetGlAbstraction().ClearBoundTextures();
 444   application.SendNotification();
 445   application.Render();
 446
 447   // Check that nothing was rendered
 448   DALI_TEST_EQUALS( boundTextures.size(), 0u, TEST_LOCATION );
 449
 450   END_TEST;
 451 }
 452
 453
 454 int UtcDaliRenderTaskSetSourceActorP02(void)
 455 {
 456   TestApplication application;
 457
 458   tet_infoline("Testing RenderTask::SetSourceActor() Positive - check that switching source from a non-renderable to a renderable actor causes the texture to be drawn");
 459
 460   Stage stage = Stage::GetCurrent();
 461
 462   const std::vector<GLuint>& boundTextures = application.GetGlAbstraction().GetBoundTextures( GL_TEXTURE0 );
 463
 464   RenderTaskList taskList = stage.GetRenderTaskList();
 465
 466   RenderTask task = taskList.GetTask( 0u );
 467
 468   Actor actor = task.GetSourceActor();
 469   DALI_TEST_CHECK( actor );
 470
 471   std::vector<GLuint> ids;
 472   ids.push_back( 7 );
 473   application.GetGlAbstraction().SetNextTextureIds( ids );
 474
 475   BufferImage img = BufferImage::New( 1,1 );
 476   ImageActor newActor = ImageActor::New( img );
 477   newActor.SetSize(1,1);
 478   stage.Add( newActor );
 479
 480   Actor nonRenderableActor = Actor::New();
 481   stage.Add( nonRenderableActor );
 482
 483   // Stop the newActor from being rendered by changing the source actor
 484   DALI_TEST_CHECK( nonRenderableActor );
 485   task.SetSourceActor( nonRenderableActor );
 486   DALI_TEST_CHECK( task.GetSourceActor() != actor );
 487   DALI_TEST_CHECK( task.GetSourceActor() == nonRenderableActor );
 488
 489   // Update & Render nothing!
 490   application.GetGlAbstraction().ClearBoundTextures();
 491   application.SendNotification();
 492   application.Render();
 493
 494   // Check that nothing was rendered
 495   DALI_TEST_EQUALS( boundTextures.size(), 0u, TEST_LOCATION );
 496
 497   // Set newActor as the new source Actor
 498   task.SetSourceActor( newActor );
 499   DALI_TEST_CHECK( task.GetSourceActor() != actor );
 500   DALI_TEST_CHECK( task.GetSourceActor() == newActor );
 501
 502   // Update & Render the newActor
 503   application.GetGlAbstraction().ClearBoundTextures();
 504   application.SendNotification();
 505   application.Render();
 506
 507   // Check that the newActor was rendered
 508   DALI_TEST_EQUALS( boundTextures.size(), 1u, TEST_LOCATION );
 509   if ( boundTextures.size() )
 510   {
 511     DALI_TEST_EQUALS( boundTextures[0], 7u, TEST_LOCATION );
 512   }
 513   END_TEST;
 514 }
 515
 516 int UtcDaliRenderTaskSetSourceActorOffStage(void)
 517 {
 518   TestApplication application;
 519
 520   tet_infoline("Testing RenderTask::SetSourceActor (on/off stage testing)");
 521
 522   Stage stage = Stage::GetCurrent();
 523
 524   const std::vector<GLuint>& boundTextures = application.GetGlAbstraction().GetBoundTextures( GL_TEXTURE0 );
 525
 526   RenderTaskList taskList = stage.GetRenderTaskList();
 527
 528   RenderTask task = taskList.GetTask( 0u );
 529
 530   Actor actor = task.GetSourceActor();
 531   DALI_TEST_CHECK( actor );
 532
 533   std::vector<GLuint> ids;
 534   GLuint expectedTextureId( 3 );
 535   ids.push_back( expectedTextureId );
 536   application.GetGlAbstraction().SetNextTextureIds( ids );
 537
 538   BufferImage img = BufferImage::New( 1,1 );
 539   ImageActor newActor = ImageActor::New( img );
 540   newActor.SetSize(1,1);
 541   task.SetSourceActor( newActor );
 542   // Don't add newActor to stage yet   //'
 543
 544   // Update & Render with the actor initially off-stage
 545   application.GetGlAbstraction().ClearBoundTextures();
 546   application.SendNotification();
 547   application.Render();
 548
 549   // Check that nothing was rendered
 550   DALI_TEST_EQUALS( boundTextures.size(), 0u, TEST_LOCATION );
 551
 552   // Now add to stage
 553   stage.Add( newActor );
 554
 555   // Update & Render with the actor on-stage
 556   application.GetGlAbstraction().ClearBoundTextures();
 557   application.SendNotification();
 558   application.Render();
 559
 560   // Check that the newActor was rendered
 561   DALI_TEST_EQUALS( boundTextures.size(), 1u, TEST_LOCATION );
 562   if ( boundTextures.size() )
 563   {
 564     DALI_TEST_EQUALS( boundTextures[0], expectedTextureId, TEST_LOCATION );
 565   }
 566
 567   // Now remove from stage
 568   stage.Remove( newActor );
 569
 570   // Update & Render with the actor off-stage
 571   application.GetGlAbstraction().ClearBoundTextures();
 572   application.SendNotification();
 573   application.Render();
 574   END_TEST;
 575 }
 576
 577 int UtcDaliRenderTaskSetSourceActorEmpty(void)
 578 {
 579   TestApplication application;
 580
 581   tet_infoline("Testing RenderTask::SetSourceActor (empty handle case)");
 582
 583   Stage stage = Stage::GetCurrent();
 584
 585   const std::vector<GLuint>& boundTextures = application.GetGlAbstraction().GetBoundTextures( GL_TEXTURE0 );
 586
 587   RenderTaskList taskList = stage.GetRenderTaskList();
 588
 589   RenderTask task = taskList.GetTask( 0u );
 590
 591   Actor actor = task.GetSourceActor();
 592   DALI_TEST_CHECK( actor );
 593
 594   std::vector<GLuint> ids;
 595   GLuint expectedTextureId( 5 );
 596   ids.push_back( expectedTextureId );
 597   application.GetGlAbstraction().SetNextTextureIds( ids );
 598
 599   BufferImage img = BufferImage::New( 1,1 );
 600   ImageActor newActor = ImageActor::New( img );
 601   newActor.SetSize(1,1);
 602   stage.Add( newActor );
 603
 604   Actor nonRenderableActor = Actor::New();
 605   stage.Add( nonRenderableActor );
 606
 607   // Set with empty handle
 608   task.SetSourceActor( Actor() );
 609   DALI_TEST_CHECK( ! task.GetSourceActor() );
 610
 611   // Update & Render nothing!
 612   application.GetGlAbstraction().ClearBoundTextures();
 613   application.SendNotification();
 614   application.Render();
 615
 616   // Check that nothing was rendered
 617   DALI_TEST_EQUALS( boundTextures.size(), 0u, TEST_LOCATION );
 618
 619   // Set with non-empty handle
 620   task.SetSourceActor( newActor );
 621   DALI_TEST_CHECK( task.GetSourceActor() == newActor );
 622
 623   // Update & Render the newActor
 624   application.GetGlAbstraction().ClearBoundTextures();
 625   application.SendNotification();
 626   application.Render();
 627
 628   // Check that the newActor was rendered
 629   DALI_TEST_EQUALS( boundTextures.size(), 1u, TEST_LOCATION );
 630   if ( boundTextures.size() )
 631   {
 632     DALI_TEST_EQUALS( boundTextures[0], expectedTextureId, TEST_LOCATION );
 633   }
 634   END_TEST;
 635 }
 636
 637 int UtcDaliRenderTaskGetSourceActorP01(void)
 638 {
 639   TestApplication application;
 640
 641   tet_infoline("Testing RenderTask::GetSourceActor() Check the default render task has a valid source actor");
 642
 643   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 644
 645   RenderTask task = taskList.GetTask( 0u );
 646
 647   Actor actor = task.GetSourceActor();
 648   DALI_TEST_CHECK( actor );
 649
 650   // By default the entire scene should be rendered
 651   Actor root = Stage::GetCurrent().GetLayer( 0 );
 652   DALI_TEST_CHECK( root == actor );
 653   END_TEST;
 654 }
 655
 656 int UtcDaliRenderTaskGetSourceActorP02(void)
 657 {
 658   TestApplication application;
 659
 660   tet_infoline("Testing RenderTask::GetSourceActor() Create a new render task, Add a new actor to the stage and set it as the source of the new render task. Get its source actor and check that it is equivalent to what was set.");
 661
 662   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 663   RenderTask task = taskList.CreateTask();
 664   Actor actor = Actor::New();
 665   Stage::GetCurrent().Add(actor);
 666   task.SetSourceActor( actor );
 667
 668   DALI_TEST_EQUALS( actor, task.GetSourceActor(), TEST_LOCATION );
 669
 670   END_TEST;
 671 }
 672
 673 int UtcDaliRenderTaskGetSourceActorN(void)
 674 {
 675   TestApplication application;
 676
 677   tet_infoline("Testing RenderTask::GetSourceActor() Try with empty handle");
 678
 679   RenderTask task;
 680   try
 681   {
 682     Actor actor = task.GetSourceActor();
 683   }
 684   catch (Dali::DaliException(e))
 685   {
 686     DALI_TEST_PRINT_ASSERT( e );
 687     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
 688   }
 689
 690   END_TEST;
 691 }
 692
 693 int UtcDaliRenderTaskSetExclusive(void)
 694 {
 695   TestApplication application;
 696
 697   tet_infoline("Testing RenderTask::SetExclusive() Check that exclusion works");
 698
 699   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 700
 701   // Manipulate the GenTextures behaviour, to identify different ImageActors
 702
 703   std::vector<GLuint> ids;
 704   ids.push_back( 8 ); // 8 = actor1
 705   ids.push_back( 9 ); // 9 = actor2
 706   ids.push_back( 10 ); // 10 = actor3
 707   application.GetGlAbstraction().SetNextTextureIds( ids );
 708
 709   BufferImage img1 = BufferImage::New( 1,1 );
 710   ImageActor actor1 = ImageActor::New( img1 );
 711   actor1.SetSize(1,1);
 712   Stage::GetCurrent().Add( actor1 );
 713
 714   // Update & Render actor1
 715   application.SendNotification();
 716   application.Render();
 717
 718   // Check that the actor1 was rendered
 719   const std::vector<GLuint>& boundTextures = application.GetGlAbstraction().GetBoundTextures( GL_TEXTURE0 );
 720   DALI_TEST_EQUALS( boundTextures.size(), 1u, TEST_LOCATION );
 721
 722   if ( boundTextures.size() )
 723   {
 724     DALI_TEST_EQUALS( boundTextures[0], 8u/*unique to actor1*/, TEST_LOCATION );
 725   }
 726
 727   BufferImage img2 = BufferImage::New( 1,1 );
 728   ImageActor actor2 = ImageActor::New( img2 );
 729   actor2.SetSize(1,1);
 730
 731   // Force actor2 to be rendered before actor1
 732   Layer layer = Layer::New();
 733   Stage::GetCurrent().Add( layer );
 734   layer.Add( actor2 );
 735   layer.LowerToBottom();
 736
 737   // Update & Render
 738   application.GetGlAbstraction().ClearBoundTextures();
 739   application.SendNotification();
 740   application.Render();
 741
 742   // Check that the actors were rendered
 743   DALI_TEST_EQUALS( boundTextures.size(), 2u, TEST_LOCATION );
 744
 745   if ( boundTextures.size() )
 746   {
 747     DALI_TEST_EQUALS( boundTextures[0], 9u/*unique to actor2*/, TEST_LOCATION );
 748     DALI_TEST_EQUALS( boundTextures[1], 8u/*unique to actor1*/, TEST_LOCATION );
 749   }
 750
 751   BufferImage img3 = BufferImage::New( 1,1 );
 752   ImageActor actor3 = ImageActor::New( img3 );
 753   actor3.SetSize(1,1);
 754
 755   // Force actor3 to be rendered before actor2
 756   layer = Layer::New();
 757   Stage::GetCurrent().Add( layer );
 758   layer.Add( actor3 );
 759   layer.LowerToBottom();
 760
 761   // Update & Render all actors
 762   application.GetGlAbstraction().ClearBoundTextures();
 763   application.SendNotification();
 764   application.Render();
 765
 766   // Check that the actors were rendered
 767   DALI_TEST_EQUALS( boundTextures.size(), 3u, TEST_LOCATION );
 768
 769   if ( boundTextures.size() )
 770   {
 771     DALI_TEST_EQUALS( boundTextures[0], 10u/*unique to actor3*/, TEST_LOCATION );
 772     DALI_TEST_EQUALS( boundTextures[1], 9u/*unique to actor2*/, TEST_LOCATION );
 773     DALI_TEST_EQUALS( boundTextures[2], 8u/*unique to actor1*/, TEST_LOCATION );
 774   }
 775
 776   // Both actors are now connected to the root node
 777   // Setup 2 render-tasks - the first will render from the root-node, and the second from actor2
 778
 779   // Not exclusive is the default
 780   RenderTask task1 = taskList.GetTask( 0u );
 781   DALI_TEST_CHECK( false == task1.IsExclusive() );
 782
 783   RenderTask task2 = taskList.CreateTask();
 784   DALI_TEST_CHECK( false == task2.IsExclusive() );
 785   task2.SetSourceActor( actor2 );
 786
 787   // Task1 should render all actors, and task 2 should render only actor2
 788
 789   application.GetGlAbstraction().ClearBoundTextures();
 790   application.SendNotification();
 791   application.Render();
 792
 793   DALI_TEST_EQUALS( boundTextures.size(), 4u, TEST_LOCATION );
 794
 795   if ( boundTextures.size() == 4 )
 796   {
 797     // Test that task 1 renders actor3, then actor2 & then actor1
 798     DALI_TEST_CHECK( boundTextures[0] == 10u );
 799     DALI_TEST_CHECK( boundTextures[1] == 9u );
 800     DALI_TEST_CHECK( boundTextures[2] == 8u );
 801
 802     // Test that task 2 renders actor2
 803     DALI_TEST_EQUALS( boundTextures[3], 9u, TEST_LOCATION );
 804   }
 805
 806   // Make actor2 exclusive to task2
 807
 808   task2.SetExclusive( true );
 809   DALI_TEST_CHECK( true == task2.IsExclusive() );
 810
 811   // Task1 should render only actor1, and task 2 should render only actor2
 812
 813   application.GetGlAbstraction().ClearBoundTextures();
 814   application.SendNotification();
 815   application.Render();
 816
 817   DALI_TEST_EQUALS( boundTextures.size(), 3u, TEST_LOCATION );
 818   if ( boundTextures.size() == 3 )
 819   {
 820     // Test that task 1 renders actor3 & actor1
 821     DALI_TEST_CHECK( boundTextures[0] == 10u );
 822     DALI_TEST_CHECK( boundTextures[1] == 8u );
 823
 824     // Test that task 2 renders actor2
 825     DALI_TEST_CHECK( boundTextures[2] == 9u );
 826   }
 827   END_TEST;
 828 }
 829
 830 int UtcDaliRenderTaskSetExclusive02(void)
 831 {
 832   TestApplication application;
 833
 834   tet_infoline("Testing RenderTask::SetExclusive() Check that changing from exclusive to not-exclusive works");
 835
 836   std::vector<GLuint> ids;
 837   ids.push_back( 8 ); // 8 = actor1
 838   application.GetGlAbstraction().SetNextTextureIds( ids );
 839
 840   BufferImage img1 = BufferImage::New( 1,1 );
 841   ImageActor actor1 = ImageActor::New( img1 );
 842   actor1.SetSize(1,1);
 843   Stage::GetCurrent().Add( actor1 );
 844
 845   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 846   RenderTask task = taskList.CreateTask();
 847
 848   task.SetSourceActor( actor1 );
 849   task.SetExclusive(true); // Actor should only render once
 850
 851   TestGlAbstraction& gl = application.GetGlAbstraction();
 852   TraceCallStack& drawTrace = gl.GetDrawTrace();
 853   drawTrace.Enable(true);
 854
 855   // Update & Render actor1
 856   application.SendNotification();
 857   application.Render();
 858
 859   DALI_TEST_EQUALS( drawTrace.CountMethod("DrawArrays"), 1, TEST_LOCATION );
 860
 861   // Set task to non-exclusive - actor1 should render twice:
 862   drawTrace.Reset();
 863   task.SetExclusive(false);
 864   application.SendNotification();
 865   application.Render();
 866
 867   DALI_TEST_EQUALS( drawTrace.CountMethod("DrawArrays"), 2, TEST_LOCATION );
 868
 869   END_TEST;
 870 }
 871
 872 int UtcDaliRenderTaskSetExclusiveN(void)
 873 {
 874   TestApplication application;
 875
 876   tet_infoline("Testing RenderTask::SetExclusive() on empty handle");
 877
 878   RenderTask task;
 879   try
 880   {
 881     task.SetExclusive(true);
 882   }
 883   catch (Dali::DaliException(e))
 884   {
 885     DALI_TEST_PRINT_ASSERT( e );
 886     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
 887   }
 888   END_TEST;
 889 }
 890
 891 int UtcDaliRenderTaskIsExclusive01(void)
 892 {
 893   TestApplication application;
 894
 895   tet_infoline("Testing RenderTask::IsExclusive() Check default values are non-exclusive");
 896
 897   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 898
 899   // Not exclusive is the default
 900   RenderTask task = taskList.GetTask( 0u );
 901   DALI_TEST_CHECK( false == task.IsExclusive() );
 902
 903   RenderTask newTask = taskList.CreateTask();
 904   DALI_TEST_CHECK( false == newTask.IsExclusive() );
 905
 906   END_TEST;
 907 }
 908
 909 int UtcDaliRenderTaskIsExclusive02(void)
 910 {
 911   TestApplication application;
 912
 913   tet_infoline("Testing RenderTask::IsExclusive() Check the getter returns set values");
 914
 915   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 916
 917   // Not exclusive is the default
 918   RenderTask newTask = taskList.CreateTask();
 919   DALI_TEST_EQUALS( newTask.IsExclusive(), false, TEST_LOCATION );
 920
 921   newTask.SetExclusive(true);
 922   DALI_TEST_EQUALS( newTask.IsExclusive(), true, TEST_LOCATION );
 923   END_TEST;
 924 }
 925
 926 int UtcDaliRenderTaskIsExclusiveN(void)
 927 {
 928   TestApplication application;
 929
 930   tet_infoline("Testing RenderTask::IsExclusive() on empty handle");
 931
 932   RenderTask task;
 933   try
 934   {
 935     bool x = task.IsExclusive();
 936     x=x;
 937   }
 938   catch (Dali::DaliException(e))
 939   {
 940     DALI_TEST_PRINT_ASSERT( e );
 941     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
 942   }
 943   END_TEST;
 944 }
 945
 946 int UtcDaliRenderTaskSetInputEnabled(void)
 947 {
 948   TestApplication application;
 949
 950   tet_infoline("Testing RenderTask::SetInputEnabled()");
 951
 952   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 953
 954   // Input is enabled by default
 955   RenderTask task = taskList.GetTask( 0u );
 956   DALI_TEST_CHECK( true == task.GetInputEnabled() );
 957
 958   task.SetInputEnabled( false );
 959   DALI_TEST_CHECK( false == task.GetInputEnabled() );
 960
 961   task.SetInputEnabled( true );
 962   DALI_TEST_CHECK( true == task.GetInputEnabled() );
 963   END_TEST;
 964 }
 965
 966 int UtcDaliRenderTaskGetInputEnabled(void)
 967 {
 968   TestApplication application;
 969
 970   tet_infoline("Testing RenderTask::GetInputEnabled()");
 971
 972   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 973
 974   // Input is enabled by default
 975   RenderTask task = taskList.GetTask( 0u );
 976   DALI_TEST_EQUALS( true, task.GetInputEnabled(), TEST_LOCATION );
 977
 978   RenderTask newTask = taskList.CreateTask();
 979   DALI_TEST_EQUALS( true, newTask.GetInputEnabled(), TEST_LOCATION );
 980
 981   newTask.SetInputEnabled(false);
 982   DALI_TEST_EQUALS( false, newTask.GetInputEnabled(), TEST_LOCATION );
 983
 984   END_TEST;
 985 }
 986
 987 int UtcDaliRenderTaskSetCameraActorP(void)
 988 {
 989   TestApplication application;
 990
 991   tet_infoline("Testing RenderTask::SetCameraActor()");
 992
 993   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
 994
 995   RenderTask task = taskList.GetTask( 0u );
 996
 997   Actor defaultCameraActor = task.GetCameraActor();
 998   DALI_TEST_CHECK( defaultCameraActor );
 999
1000   CameraActor newCameraActor = CameraActor::New();
1001   DALI_TEST_CHECK( newCameraActor );
1002
1003   task.SetCameraActor( newCameraActor );
1004   DALI_TEST_CHECK( task.GetCameraActor() != defaultCameraActor );
1005   DALI_TEST_EQUALS( task.GetCameraActor(), newCameraActor, TEST_LOCATION );
1006   END_TEST;
1007 }
1008
1009
1010 int UtcDaliRenderTaskSetCameraActorN(void)
1011 {
1012   TestApplication application;
1013
1014   tet_infoline("Testing RenderTask::SetCameraActor() with empty actor handle");
1015
1016   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1017
1018   RenderTask task = taskList.GetTask( 0u );
1019
1020   Actor actor = task.GetCameraActor();
1021   DALI_TEST_CHECK( actor );
1022
1023   CameraActor cameraActor;
1024
1025   task.SetCameraActor( cameraActor );
1026   DALI_TEST_EQUALS( (bool)task.GetCameraActor(), false, TEST_LOCATION );
1027   DALI_TEST_EQUALS( task.GetCameraActor(), cameraActor, TEST_LOCATION );
1028   END_TEST;
1029 }
1030
1031
1032 int UtcDaliRenderTaskGetCameraActorP(void)
1033 {
1034   TestApplication application;
1035
1036   tet_infoline("Testing RenderTask::GetCameraActor()");
1037
1038   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1039
1040   RenderTask task = taskList.GetTask( 0u );
1041
1042   CameraActor actor = task.GetCameraActor();
1043   DALI_TEST_CHECK( actor );
1044   DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
1045   DALI_TEST_GREATER( actor.GetFieldOfView(), 0.0f, TEST_LOCATION );
1046   END_TEST;
1047 }
1048
1049 int UtcDaliRenderTaskGetCameraActorN(void)
1050 {
1051   TestApplication application;
1052
1053   tet_infoline("Testing RenderTask::GetCameraActor() with empty handle");
1054   RenderTask task;
1055
1056   try
1057   {
1058     Actor actor = task.GetCameraActor();
1059   }
1060   catch (Dali::DaliException(e))
1061   {
1062     DALI_TEST_PRINT_ASSERT( e );
1063     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
1064   }
1065
1066   END_TEST;
1067 }
1068
1069 int UtcDaliRenderTaskSetTargetFrameBufferP(void)
1070 {
1071   TestApplication application;
1072
1073   tet_infoline("Testing RenderTask::SetTargetFrameBuffer()");
1074
1075   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1076
1077   RenderTask task = taskList.GetTask( 0u );
1078
1079   FrameBufferImage newImage = FrameBufferImage::New();
1080   task.SetTargetFrameBuffer( newImage );
1081   DALI_TEST_CHECK( task.GetTargetFrameBuffer() == newImage );
1082   END_TEST;
1083 }
1084
1085 int UtcDaliRenderTaskSetTargetFrameBufferN(void)
1086 {
1087   TestApplication application;
1088
1089   tet_infoline("Testing RenderTask::SetTargetFrameBuffer()");
1090
1091   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1092
1093   RenderTask task = taskList.GetTask( 0u );
1094   FrameBufferImage newImage; // Empty handle
1095   task.SetTargetFrameBuffer( newImage );
1096   DALI_TEST_EQUALS( (bool)task.GetTargetFrameBuffer(), false, TEST_LOCATION );
1097   END_TEST;
1098 }
1099
1100 int UtcDaliRenderTaskGetTargetFrameBufferP(void)
1101 {
1102   TestApplication application;
1103
1104   tet_infoline("Testing RenderTask::GetTargetFrameBuffer()");
1105
1106   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1107
1108   RenderTask newTask = taskList.CreateTask();
1109   FrameBufferImage fb = FrameBufferImage::New(128, 128, Pixel::RGBA8888);
1110   newTask.SetTargetFrameBuffer( fb );
1111   DALI_TEST_EQUALS( newTask.GetTargetFrameBuffer(), fb, TEST_LOCATION );
1112   END_TEST;
1113 }
1114
1115 int UtcDaliRenderTaskGetTargetFrameBufferN(void)
1116 {
1117   TestApplication application;
1118
1119   tet_infoline("Testing RenderTask::GetTargetFrameBuffer()");
1120
1121   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1122
1123   RenderTask task = taskList.GetTask( 0u );
1124
1125   // By default render-tasks do not render off-screen
1126   FrameBufferImage image = task.GetTargetFrameBuffer();
1127   DALI_TEST_CHECK( !image );
1128
1129   END_TEST;
1130 }
1131
1132 int UtcDaliRenderTaskSetScreenToFrameBufferFunctionP(void)
1133 {
1134   TestApplication application;
1135
1136   tet_infoline("Testing RenderTask::SetScreenToFrameBufferFunction()");
1137
1138   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1139
1140   RenderTask task = taskList.GetTask( 0u );
1141
1142   task.SetScreenToFrameBufferFunction( TestScreenToFrameBufferFunction );
1143
1144   Vector2 coordinates( 5, 10 );
1145   Vector2 convertedCoordinates( 6, 12 ); // + Vector(1, 2)
1146
1147   RenderTask::ScreenToFrameBufferFunction func = task.GetScreenToFrameBufferFunction();
1148   DALI_TEST_CHECK( func( coordinates ) );
1149   DALI_TEST_CHECK( coordinates == convertedCoordinates );
1150
1151   task.SetScreenToFrameBufferFunction( RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION );
1152   func = task.GetScreenToFrameBufferFunction();
1153   DALI_TEST_CHECK( func( coordinates ) );
1154
1155   task.SetScreenToFrameBufferFunction( RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION );
1156   func = task.GetScreenToFrameBufferFunction();
1157   DALI_TEST_CHECK( ! func( coordinates ) );
1158   END_TEST;
1159 }
1160
1161 int UtcDaliRenderTaskSetScreenToFrameBufferFunctionN(void)
1162 {
1163   TestApplication application;
1164
1165   tet_infoline("Testing RenderTask::SetScreenToFrameBufferFunction()");
1166
1167   RenderTask task; // Empty handle
1168   try
1169   {
1170     task.SetScreenToFrameBufferFunction( TestScreenToFrameBufferFunction );
1171   }
1172   catch (Dali::DaliException(e))
1173   {
1174     DALI_TEST_PRINT_ASSERT( e );
1175     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
1176   }
1177   END_TEST;
1178 }
1179
1180 int UtcDaliRenderTaskGetScreenToFrameBufferFunctionP(void)
1181 {
1182   TestApplication application;
1183
1184   tet_infoline("Testing RenderTask::GetScreenToFrameBufferFunction()");
1185
1186   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1187
1188   RenderTask task = taskList.GetTask( 0u );
1189
1190   Vector2 originalCoordinates( 5, 10 );
1191   Vector2 coordinates( 5, 10 );
1192
1193   RenderTask::ScreenToFrameBufferFunction func = task.GetScreenToFrameBufferFunction();
1194   DALI_TEST_CHECK( !func( coordinates ) ); // conversion should fail by default
1195   DALI_TEST_CHECK( coordinates == originalCoordinates ); // coordinates should not be modified
1196   END_TEST;
1197 }
1198
1199 int UtcDaliRenderTaskGetScreenToFrameBufferFunctionN(void)
1200 {
1201   TestApplication application;
1202
1203   tet_infoline("Testing RenderTask::GetScreenToFrameBufferFunction() on empty handle");
1204
1205   RenderTask task;
1206   try
1207   {
1208     RenderTask::ScreenToFrameBufferFunction func = task.GetScreenToFrameBufferFunction();
1209     func=func;
1210   }
1211   catch (Dali::DaliException(e))
1212   {
1213     DALI_TEST_PRINT_ASSERT( e );
1214     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
1215   }
1216   END_TEST;
1217 }
1218
1219
1220 int UtcDaliRenderTaskGetScreenToFrameBufferMappingActorP(void)
1221 {
1222   TestApplication application;
1223   tet_infoline("Testing RenderTask::GetScreenToFrameBufferMappingActor ");
1224
1225   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1226   RenderTask renderTask = taskList.CreateTask();
1227   Actor mappingActor = Actor::New();
1228   renderTask.SetScreenToFrameBufferMappingActor(mappingActor);
1229
1230   DALI_TEST_EQUALS( mappingActor, renderTask.GetScreenToFrameBufferMappingActor(), TEST_LOCATION );
1231   END_TEST;
1232 }
1233
1234
1235 int UtcDaliRenderTaskGetScreenToFrameBufferMappingActorN(void)
1236 {
1237   TestApplication application;
1238   tet_infoline("Testing RenderTask::GetScreenToFrameBufferMappingActor with empty task handle");
1239
1240   RenderTask task;
1241   try
1242   {
1243     Actor mappingActor;
1244     task.SetScreenToFrameBufferMappingActor(mappingActor);
1245   }
1246   catch (Dali::DaliException(e))
1247   {
1248     DALI_TEST_PRINT_ASSERT( e );
1249     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
1250   }
1251   END_TEST;
1252 }
1253
1254 int UtcDaliRenderTaskGetScreenToFrameBufferMappingActor02N(void)
1255 {
1256   TestApplication application;
1257   tet_infoline("Testing RenderTask::GetScreenToFrameBufferMappingActor with empty task handle");
1258
1259   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1260   RenderTask renderTask = taskList.CreateTask();
1261   Actor actor;
1262   renderTask.SetScreenToFrameBufferMappingActor(actor);
1263
1264   DALI_TEST_EQUALS( (bool)renderTask.GetScreenToFrameBufferMappingActor(), false, TEST_LOCATION);
1265   END_TEST;
1266 }
1267
1268 int UtcDaliRenderTaskGetViewportP01(void)
1269 {
1270   TestApplication application;
1271
1272   tet_infoline("Testing RenderTask::GetViewport() on default task");
1273
1274   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1275   RenderTask task = taskList.GetTask( 0u );
1276   Viewport viewport = task.GetViewport();
1277
1278   // By default the viewport should match the stage width/height
1279   Vector2 stageSize = Stage::GetCurrent().GetSize();
1280   Viewport expectedViewport( 0, 0, stageSize.width, stageSize.height );
1281   DALI_TEST_CHECK( viewport == expectedViewport );
1282   END_TEST;
1283 }
1284
1285 int UtcDaliRenderTaskGetViewportP02(void)
1286 {
1287   TestApplication application;
1288
1289   tet_infoline("Testing RenderTask::GetViewport() on new task");
1290
1291   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1292   RenderTask task = taskList.CreateTask();
1293   Viewport viewport = task.GetViewport();
1294
1295   // By default the viewport should match the stage width/height
1296   Vector2 stageSize = Stage::GetCurrent().GetSize();
1297   Viewport expectedViewport( 0, 0, stageSize.width, stageSize.height );
1298   DALI_TEST_CHECK( viewport == expectedViewport );
1299   END_TEST;
1300 }
1301
1302 int UtcDaliRenderTaskGetViewportN(void)
1303 {
1304   TestApplication application;
1305
1306   tet_infoline("Testing RenderTask::GetViewport() on empty handle");
1307
1308   RenderTask task;
1309   try
1310   {
1311     Viewport viewport = task.GetViewport();
1312     viewport = viewport;
1313   }
1314   catch (Dali::DaliException(e))
1315   {
1316     DALI_TEST_PRINT_ASSERT( e );
1317     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
1318   }
1319   END_TEST;
1320 }
1321
1322
1323 int UtcDaliRenderTaskSetViewportP(void)
1324 {
1325   TestApplication application;
1326
1327   tet_infoline("Testing RenderTask::SetViewport()");
1328
1329   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1330
1331   RenderTask task = taskList.GetTask( 0u );
1332   Vector2 stageSize = Stage::GetCurrent().GetSize();
1333   Viewport newViewport( 0, 0, stageSize.width * 0.5f, stageSize.height * 0.5f );
1334   task.SetViewport( newViewport );
1335
1336   // Update (viewport is a property)
1337   application.SendNotification();
1338   application.Render();
1339
1340   DALI_TEST_CHECK( task.GetViewport() == newViewport );
1341   END_TEST;
1342 }
1343
1344 int UtcDaliRenderTaskSetViewportN(void)
1345 {
1346   TestApplication application;
1347
1348   tet_infoline("Testing RenderTask::SetViewport()");
1349
1350   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1351
1352   RenderTask task;
1353   try
1354   {
1355     Vector2 stageSize = Stage::GetCurrent().GetSize();
1356     Viewport newViewport( 0, 0, stageSize.width * 0.5f, stageSize.height * 0.5f );
1357     task.SetViewport( newViewport );
1358   }
1359   catch (Dali::DaliException(e))
1360   {
1361     DALI_TEST_PRINT_ASSERT( e );
1362     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
1363   }
1364
1365   END_TEST;
1366 }
1367
1368
1369 int UtcDaliRenderTaskSetViewportPosition(void)
1370 {
1371   TestApplication application;
1372
1373   tet_infoline("Testing RenderTask::SetViewportPosition()");
1374
1375   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1376
1377   RenderTask task = taskList.GetTask( 0u );
1378
1379   Viewport viewport = task.GetViewport();
1380
1381   // By default the viewport should match the stage width/height
1382
1383   Vector2 stageSize = Stage::GetCurrent().GetSize();
1384   Viewport expectedViewport( 0, 0, stageSize.width, stageSize.height );
1385   DALI_TEST_CHECK( viewport == expectedViewport );
1386
1387   // 'Setter' test
1388   Vector2 newPosition(25.0f, 50.0f);
1389   task.SetViewportPosition( newPosition );
1390
1391   // Update (viewport is a property)
1392   application.SendNotification();
1393   application.Render();
1394
1395   DALI_TEST_EQUALS( task.GetCurrentViewportPosition(), newPosition, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1396
1397   // Set by Property test
1398   Vector2 newPosition2(32.0f, 32.0f);
1399   task.SetProperty( RenderTask::Property::VIEWPORT_POSITION, newPosition2 );
1400
1401   // Update
1402   application.SendNotification();
1403   application.Render();
1404
1405   DALI_TEST_EQUALS( task.GetCurrentViewportPosition(), newPosition2, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1406
1407   Vector2 newPosition3(64.0f, 0.0f);
1408   Animation animation = Animation::New(1.0f);
1409   animation.AnimateTo( Property( task, RenderTask::Property::VIEWPORT_POSITION ), newPosition3, AlphaFunction::LINEAR );
1410   animation.Play();
1411
1412   // Perform 1000ms worth of updates at which point animation should have completed.
1413   Wait(application, 1000);
1414   DALI_TEST_EQUALS( task.GetCurrentViewportPosition(), newPosition3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1415   END_TEST;
1416 }
1417
1418 int UtcDaliRenderTaskSetViewportSize(void)
1419 {
1420   TestApplication application;
1421
1422   tet_infoline("Testing RenderTask::SetViewportSize()");
1423
1424   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1425
1426   RenderTask task = taskList.GetTask( 0u );
1427
1428   Viewport viewport = task.GetViewport();
1429
1430   // By default the viewport should match the stage width/height
1431
1432   Vector2 stageSize = Stage::GetCurrent().GetSize();
1433   Viewport expectedViewport( 0, 0, stageSize.width, stageSize.height );
1434   DALI_TEST_CHECK( viewport == expectedViewport );
1435
1436   Vector2 newSize(128.0f, 64.0f);
1437   task.SetViewportSize( newSize );
1438
1439   // Update (viewport is a property)
1440   application.SendNotification();
1441   application.Render();
1442
1443   DALI_TEST_EQUALS( task.GetCurrentViewportSize(), newSize, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1444
1445   // Set by Property test
1446   Vector2 newSize2(50.0f, 50.0f);
1447   task.SetProperty( RenderTask::Property::VIEWPORT_SIZE, newSize2 );
1448
1449   // Update
1450   application.SendNotification();
1451   application.Render();
1452
1453   DALI_TEST_EQUALS( task.GetCurrentViewportSize(), newSize2, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1454
1455   Vector2 newSize3(10.0f, 10.0f);
1456   Animation animation = Animation::New(1.0f);
1457   animation.AnimateTo( Property( task, RenderTask::Property::VIEWPORT_SIZE ), newSize3, AlphaFunction::LINEAR );
1458   animation.Play();
1459
1460   // Perform 1000ms worth of updates at which point animation should have completed.
1461   Wait(application, 1000);
1462   DALI_TEST_EQUALS( task.GetCurrentViewportSize(), newSize3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
1463
1464   END_TEST;
1465 }
1466
1467 int UtcDaliRenderTaskSetClearColorP(void)
1468 {
1469   TestApplication application;
1470
1471   tet_infoline("Testing RenderTask::SetClearColor()");
1472
1473   Vector4 testColor( 1.0f, 2.0f, 3.0f, 4.0f );
1474   Vector4 testColor2( 5.0f, 6.0f, 7.0f, 8.0f );
1475
1476   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1477
1478   RenderTask task = taskList.GetTask( 0u );
1479   DALI_TEST_CHECK( task.GetClearColor() != testColor );
1480
1481   task.SetClearColor( testColor );
1482
1483   // Wait a frame.
1484   Wait(application);
1485
1486   DALI_TEST_EQUALS( task.GetClearColor(), testColor, TEST_LOCATION );
1487
1488   task.SetProperty( RenderTask::Property::CLEAR_COLOR, testColor2 );
1489
1490   // Wait a frame.
1491   Wait(application);
1492
1493   DALI_TEST_EQUALS( task.GetClearColor(), testColor2, TEST_LOCATION );
1494   END_TEST;
1495 }
1496
1497 int UtcDaliRenderTaskSetClearColorN(void)
1498 {
1499   TestApplication application;
1500
1501   tet_infoline("Testing RenderTask::SetClearColor() on empty handle");
1502
1503   RenderTask task;
1504   try
1505   {
1506     task.SetClearColor( Vector4::ZERO );
1507   }
1508   catch (Dali::DaliException(e))
1509   {
1510     DALI_TEST_PRINT_ASSERT( e );
1511     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
1512   }
1513   END_TEST;
1514 }
1515
1516 int UtcDaliRenderTaskGetClearColorP(void)
1517 {
1518   TestApplication application;
1519
1520   tet_infoline("Testing RenderTask::GetClearColor()");
1521
1522   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1523   RenderTask task = taskList.GetTask( 0u );
1524   DALI_TEST_EQUALS( task.GetClearColor(), RenderTask::DEFAULT_CLEAR_COLOR, TEST_LOCATION );
1525   END_TEST;
1526 }
1527
1528 int UtcDaliRenderTaskGetClearColorN(void)
1529 {
1530   TestApplication application;
1531
1532   tet_infoline("Testing RenderTask::GetClearColor()");
1533
1534   RenderTask task;
1535   try
1536   {
1537     Vector4 color = task.GetClearColor();
1538     color = color;
1539   }
1540   catch (Dali::DaliException(e))
1541   {
1542     DALI_TEST_PRINT_ASSERT( e );
1543     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
1544   }
1545   END_TEST;
1546 }
1547
1548 int UtcDaliRenderTaskSetClearEnabledP(void)
1549 {
1550   TestApplication application;
1551
1552   tet_infoline("Testing RenderTask::SetClearEnabled()");
1553
1554   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1555
1556   RenderTask task = taskList.GetTask( 0u );
1557   DALI_TEST_CHECK( !task.GetClearEnabled() ); // defaults to false
1558
1559   task.SetClearEnabled( true );
1560   DALI_TEST_EQUALS( task.GetClearEnabled(), true, TEST_LOCATION );
1561
1562   task.SetClearEnabled( false );
1563   DALI_TEST_EQUALS( task.GetClearEnabled(), false, TEST_LOCATION );
1564   END_TEST;
1565 }
1566
1567 int UtcDaliRenderTaskSetClearEnabledN(void)
1568 {
1569   TestApplication application;
1570
1571   tet_infoline("Testing RenderTask::SetClearEnabled() with empty handle");
1572
1573   RenderTask task;
1574   try
1575   {
1576     task.SetClearEnabled(true);
1577   }
1578   catch (Dali::DaliException(e))
1579   {
1580     DALI_TEST_PRINT_ASSERT( e );
1581     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
1582   }
1583   END_TEST;
1584 }
1585
1586 int UtcDaliRenderTaskGetClearEnabledP(void)
1587 {
1588   TestApplication application;
1589
1590   tet_infoline("Testing RenderTask::GetClearEnabled()");
1591
1592   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1593
1594   RenderTask task = taskList.GetTask( 0u );
1595   DALI_TEST_CHECK( !task.GetClearEnabled() ); // defaults to false
1596   END_TEST;
1597 }
1598
1599
1600 int UtcDaliRenderTaskGetClearEnabledN(void)
1601 {
1602   TestApplication application;
1603
1604   tet_infoline("Testing RenderTask::GetClearEnabled() with empty handle");
1605
1606   RenderTask task;
1607   try
1608   {
1609     bool x = task.GetClearEnabled();
1610     x=x;
1611   }
1612   catch (Dali::DaliException(e))
1613   {
1614     DALI_TEST_PRINT_ASSERT( e );
1615     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
1616   }
1617   END_TEST;
1618 }
1619
1620 int UtcDaliRenderTaskSetCullModeP(void)
1621 {
1622   TestApplication application;
1623
1624   tet_infoline("Testing RenderTask::SetCullMode()");
1625
1626   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1627   RenderTask task = taskList.GetTask( 0u );
1628   DALI_TEST_EQUALS( task.GetCullMode(), true, TEST_LOCATION );
1629
1630   task.SetCullMode( false );
1631
1632   DALI_TEST_EQUALS( task.GetCullMode(), false, TEST_LOCATION );
1633
1634   END_TEST;
1635 }
1636
1637 int UtcDaliRenderTaskSetCullModeN(void)
1638 {
1639   TestApplication application;
1640
1641   tet_infoline("Testing RenderTask::SetCullMode() on empty handle");
1642
1643   RenderTask task;
1644   try
1645   {
1646     task.SetCullMode( false );
1647   }
1648   catch (Dali::DaliException(e))
1649   {
1650     DALI_TEST_PRINT_ASSERT( e );
1651     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
1652   }
1653   END_TEST;
1654 }
1655
1656 int UtcDaliRenderTaskGetCullModeP(void)
1657 {
1658   TestApplication application;
1659
1660   tet_infoline("Testing RenderTask::GetCullMode()");
1661
1662   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1663   RenderTask task = taskList.GetTask( 0u );
1664   DALI_TEST_EQUALS( task.GetCullMode(), true, TEST_LOCATION );
1665   END_TEST;
1666 }
1667
1668 int UtcDaliRenderTaskGetCullModeN(void)
1669 {
1670   TestApplication application;
1671
1672   tet_infoline("Testing RenderTask::GetCullMode() with empty handle");
1673
1674   RenderTask task;
1675   try
1676   {
1677     bool x = task.GetCullMode();
1678     x=x;
1679   }
1680   catch (Dali::DaliException(e))
1681   {
1682     DALI_TEST_PRINT_ASSERT( e );
1683     DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
1684   }
1685   END_TEST;
1686 }
1687
1688
1689 int UtcDaliRenderTaskSetRefreshRate(void)
1690 {
1691   TestApplication application;
1692
1693   tet_infoline("Testing RenderTask::SetRefreshRate()");
1694
1695   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1696
1697   // By default tasks will be processed every frame
1698   RenderTask task = taskList.GetTask( 0u );
1699   DALI_TEST_CHECK( RenderTask::REFRESH_ALWAYS == task.GetRefreshRate() );
1700
1701   task.SetRefreshRate( 2u ); // every-other frame
1702   DALI_TEST_CHECK( 2u == task.GetRefreshRate() );
1703
1704   task.SetRefreshRate( RenderTask::REFRESH_ALWAYS );
1705   DALI_TEST_CHECK( RenderTask::REFRESH_ALWAYS == task.GetRefreshRate() );
1706   END_TEST;
1707 }
1708
1709 int UtcDaliRenderTaskGetRefreshRate(void)
1710 {
1711   TestApplication application;
1712
1713   tet_infoline("Testing RenderTask::GetRefreshRate()");
1714
1715   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1716
1717   // By default tasks will be processed every frame
1718   RenderTask task = taskList.GetTask( 0u );
1719   DALI_TEST_CHECK( RenderTask::REFRESH_ALWAYS == task.GetRefreshRate() );
1720
1721   RenderTask newTask = taskList.CreateTask();
1722   DALI_TEST_CHECK( RenderTask::REFRESH_ALWAYS == newTask.GetRefreshRate() );
1723   END_TEST;
1724 }
1725
1726 int UtcDaliRenderTaskSignalFinished(void)
1727 {
1728   TestApplication application;
1729
1730   tet_infoline("Testing RenderTask::SignalFinished()");
1731
1732   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1733   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
1734
1735   CameraActor offscreenCameraActor = CameraActor::New();
1736
1737   Stage::GetCurrent().Add( offscreenCameraActor );
1738
1739   BufferImage image = BufferImage::New( 10, 10 );
1740   ImageActor rootActor = ImageActor::New( image );
1741   rootActor.SetSize( 10, 10 );
1742   Stage::GetCurrent().Add( rootActor );
1743
1744   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
1745   NativeImageInterfacePtr testNativeImagePtr = TestNativeImage::New(10, 10);
1746   FrameBufferImage frameBufferImage = FrameBufferImage::New( *testNativeImagePtr.Get() );
1747
1748   // Flush all outstanding messages
1749   application.SendNotification();
1750   application.Render();
1751
1752   RenderTask newTask = taskList.CreateTask();
1753   newTask.SetCameraActor( offscreenCameraActor );
1754   newTask.SetSourceActor( rootActor );
1755   newTask.SetInputEnabled( false );
1756   newTask.SetClearColor( Vector4( 0.f, 0.f, 0.f, 0.f ) );
1757   newTask.SetClearEnabled( true );
1758   newTask.SetExclusive( true );
1759   newTask.SetRefreshRate( RenderTask::REFRESH_ONCE );
1760   newTask.SetTargetFrameBuffer( frameBufferImage );
1761
1762   // Framebuffer doesn't actually get created until Connected, i.e. by previous line
1763
1764   bool finished = false;
1765   RenderTaskFinished renderTaskFinished( finished );
1766   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1767
1768   // Flush the queue and render.
1769   application.SendNotification();
1770
1771   // 1 render to process render task, then wait for sync before finished msg is sent
1772   // from update to the event thread.
1773
1774   application.Render();
1775   application.SendNotification();
1776   DALI_TEST_CHECK( !finished );
1777
1778   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
1779   DALI_TEST_CHECK( lastSyncObj != NULL );
1780
1781   application.Render();
1782   DALI_TEST_EQUALS( (Integration::KeepUpdating::Reasons)(application.GetUpdateStatus() & Integration::KeepUpdating::RENDER_TASK_SYNC), Integration::KeepUpdating::RENDER_TASK_SYNC, TEST_LOCATION );
1783   application.SendNotification();
1784   DALI_TEST_CHECK( !finished );
1785
1786   application.Render();
1787   DALI_TEST_EQUALS( (Integration::KeepUpdating::Reasons)(application.GetUpdateStatus() & Integration::KeepUpdating::RENDER_TASK_SYNC), Integration::KeepUpdating::RENDER_TASK_SYNC, TEST_LOCATION );
1788   application.SendNotification();
1789   DALI_TEST_CHECK( ! finished );
1790
1791   sync.SetObjectSynced( lastSyncObj, true );
1792
1793   application.Render();
1794   application.SendNotification();
1795   DALI_TEST_CHECK( !finished );
1796
1797   application.Render();
1798   application.SendNotification();
1799   DALI_TEST_CHECK( finished );
1800   finished = false;
1801
1802   application.Render(); // Double check no more finished signal
1803   application.SendNotification();
1804   DALI_TEST_CHECK( ! finished );
1805   END_TEST;
1806 }
1807
1808
1809 int UtcDaliRenderTaskContinuous01(void)
1810 {
1811   TestApplication application;
1812
1813   tet_infoline("Testing RenderTask Render Continuous using loading image\nPRE: render task not ready (source actor not staged)\nPOST:continuous renders, no Finished signal");
1814
1815   // SETUP AN OFFSCREEN RENDER TASK
1816   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1817   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1818   drawTrace.Enable(true);
1819
1820   Actor rootActor = Actor::New();
1821   Stage::GetCurrent().Add( rootActor );
1822
1823   CameraActor offscreenCameraActor = CameraActor::New();
1824   Stage::GetCurrent().Add( offscreenCameraActor );
1825
1826   ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1827   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1828   Integration::ResourceId imageRequestId = imageRequest->GetId();
1829   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1830
1831   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1832   bool finished = false;
1833   RenderTaskFinished renderTaskFinished( finished );
1834   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1835   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1836   application.SendNotification();
1837
1838   // START PROCESS/RENDER                     Input,    Expected  Input, Expected, KeepUpdating
1839   DALI_TEST_CHECK( UpdateRender(application,  drawTrace, false,   finished, false, false ) );
1840   application.GetPlatform().ClearReadyResources();
1841
1842   // ADD SOURCE ACTOR TO STAGE - expect continuous renders to start, no finished signal
1843   Stage::GetCurrent().Add(secondRootActor);
1844   application.SendNotification();
1845
1846   // CONTINUE PROCESS/RENDER                  Input,    Expected  Input,    Expected
1847   DALI_TEST_CHECK( UpdateRender(application,  drawTrace, true,    finished, false, false ) );
1848   END_TEST;
1849 }
1850
1851
1852 int UtcDaliRenderTaskContinuous02(void)
1853 {
1854   TestApplication application;
1855
1856   tet_infoline("Testing RenderTask Render Continuous using loading image\nPRE: render task not ready (source actor not visible)\nPOST:continuous renders, no Finished signal");
1857
1858   // SETUP AN OFFSCREEN RENDER TASK
1859   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1860   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1861   drawTrace.Enable(true);
1862
1863   Actor rootActor = Actor::New();
1864   Stage::GetCurrent().Add( rootActor );
1865
1866   CameraActor offscreenCameraActor = CameraActor::New();
1867   Stage::GetCurrent().Add( offscreenCameraActor );
1868
1869   ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1870   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1871   Integration::ResourceId imageRequestId = imageRequest->GetId();
1872   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1873   Stage::GetCurrent().Add(secondRootActor);
1874   secondRootActor.SetVisible(false);
1875
1876   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1877   bool finished = false;
1878   RenderTaskFinished renderTaskFinished( finished );
1879   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1880   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1881   application.SendNotification();
1882
1883   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected, KeepUpdating
1884   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, false ) );
1885   application.GetPlatform().ClearReadyResources();
1886
1887   // MAKE SOURCE ACTOR VISIBLE - expect continuous renders to start, no finished signal
1888   secondRootActor.SetVisible(true);
1889   application.SendNotification();
1890
1891   // CONTINUE PROCESS/RENDER                 Input,    Expected  Input,    Expected
1892   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
1893   END_TEST;
1894 }
1895
1896 int UtcDaliRenderTaskContinuous03(void)
1897 {
1898   TestApplication application;
1899
1900   tet_infoline("Testing RenderTask Render Continuous using loading image\nPRE: render task not ready (camera actor not staged)\nPOST:continuous renders, no Finished signal");
1901
1902   // SETUP AN OFFSCREEN RENDER TASK
1903   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1904   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1905   drawTrace.Enable(true);
1906
1907   Actor rootActor = Actor::New();
1908   Stage::GetCurrent().Add( rootActor );
1909
1910   CameraActor offscreenCameraActor = CameraActor::New();
1911   ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1912   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1913   Integration::ResourceId imageRequestId = imageRequest->GetId();
1914   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1915   Stage::GetCurrent().Add(secondRootActor);
1916
1917   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1918   bool finished = false;
1919   RenderTaskFinished renderTaskFinished( finished );
1920   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1921   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1922   application.SendNotification();
1923
1924   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1925   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, false ) );
1926   application.GetPlatform().ClearReadyResources();
1927
1928   // ADD CAMERA ACTOR TO STAGE - expect continuous renders to start, no finished signal
1929   Stage::GetCurrent().Add( offscreenCameraActor );
1930   application.SendNotification();
1931
1932   // CONTINUE PROCESS/RENDER                 Input,    Expected  Input,    Expected
1933   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
1934   END_TEST;
1935 }
1936
1937
1938 int UtcDaliRenderTaskContinuous04(void)
1939 {
1940   TestApplication application;
1941
1942   tet_infoline("Testing RenderTask Render Continuous using loading image\nPRE: Resource not ready\nPOST:continuous renders, no Finished signal");
1943
1944   // SETUP AN OFFSCREEN RENDER TASK
1945   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1946   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1947   drawTrace.Enable(true);
1948
1949   Actor rootActor = Actor::New();
1950   Stage::GetCurrent().Add( rootActor );
1951
1952   CameraActor offscreenCameraActor = CameraActor::New();
1953   Stage::GetCurrent().Add( offscreenCameraActor );
1954   ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1955   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1956   Integration::ResourceId imageRequestId = imageRequest->GetId();
1957   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1958   Stage::GetCurrent().Add(secondRootActor);
1959
1960   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
1961   bool finished = false;
1962   RenderTaskFinished renderTaskFinished( finished );
1963   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
1964   application.SendNotification();
1965
1966   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
1967   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1968   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
1969
1970   // FINISH RESOURCE LOADING - expect 'continuous' renders to start, no finished signal
1971   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
1972   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
1973   END_TEST;
1974 }
1975
1976 int UtcDaliRenderTaskContinous05(void)
1977 {
1978   TestApplication application;
1979
1980   tet_infoline("Testing RenderTask Render Continuous using Mesh which accesses texture through sampler with loading image\n"
1981                "PRE: Resource not ready\nPOST:continuous renders, no Finished signal");
1982
1983   // SETUP AN OFFSCREEN RENDER TASK
1984   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1985   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
1986   drawTrace.Enable(true);
1987
1988   Actor rootActor = Actor::New();
1989   Stage::GetCurrent().Add( rootActor );
1990
1991   CameraActor offscreenCameraActor = CameraActor::New();
1992   Stage::GetCurrent().Add( offscreenCameraActor );
1993
1994   Material material = CreateMaterial();
1995   Image image = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
1996   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
1997   Integration::ResourceId imageRequestId = imageRequest->GetId();
1998   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
1999   material.AddTexture( image, "sTexture" );
2000
2001   Geometry geometry = CreateQuadGeometry();
2002   Renderer renderer = Renderer::New(geometry, material);
2003   Actor secondRootActor = Actor::New();
2004   secondRootActor.AddRenderer(renderer);
2005   secondRootActor.SetSize(100, 100);
2006   Stage::GetCurrent().Add(secondRootActor);
2007
2008   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
2009   bool finished = false;
2010   RenderTaskFinished renderTaskFinished( finished );
2011   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2012   application.SendNotification();
2013
2014   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2015   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2016   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2017
2018   // FINISH RESOURCE LOADING - expect 'continuous' renders to start, no finished signal
2019   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2020   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
2021
2022   END_TEST;
2023 }
2024
2025
2026 int UtcDaliRenderTaskOnce01(void)
2027 {
2028   TestApplication application;
2029
2030   tet_infoline("Testing RenderTask Render Once GlSync, using loading image\nPRE: Resources not ready, Source not visible\nPOST: Finished signal sent once only");
2031
2032   // SETUP AN OFFSCREEN RENDER TASK
2033   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2034   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
2035   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2036   drawTrace.Enable(true);
2037
2038   Actor rootActor = Actor::New();
2039   Stage::GetCurrent().Add( rootActor );
2040
2041   CameraActor offscreenCameraActor = CameraActor::New();
2042   Stage::GetCurrent().Add( offscreenCameraActor );
2043   ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
2044   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
2045   Integration::ResourceId imageRequestId = imageRequest->GetId();
2046   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
2047
2048   Stage::GetCurrent().Add(secondRootActor);
2049
2050   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, true);
2051   bool finished = false;
2052   RenderTaskFinished renderTaskFinished( finished );
2053   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2054   application.SendNotification();
2055
2056   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2057   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2058   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2059
2060   // MAKE SOURCE VISIBLE
2061   secondRootActor.SetVisible(true);
2062   application.SendNotification();
2063   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2064   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2065
2066   // FINISH RESOURCE LOADING - expect no rendering yet
2067   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2068   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2069   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
2070   DALI_TEST_CHECK( lastSyncObj != NULL );
2071
2072   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2073   application.GetPlatform().ClearReadyResources();
2074   sync.SetObjectSynced( lastSyncObj, true );
2075   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,   finished, false, true  ) );
2076   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
2077   END_TEST;
2078 }
2079
2080 int UtcDaliRenderTaskOnce02(void)
2081 {
2082   TestApplication application;
2083
2084   tet_infoline("Testing RenderTask Render Once GlSync, using Mesh which accesses texture through sampler with loading image.\n"
2085                "PRE: Resources not ready\nPOST: Finished signal sent once only");
2086
2087   // SETUP AN OFFSCREEN RENDER TASK
2088   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2089   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
2090   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2091   drawTrace.Enable(true);
2092
2093   Actor rootActor = Actor::New();
2094   Stage::GetCurrent().Add( rootActor );
2095
2096   CameraActor offscreenCameraActor = CameraActor::New();
2097   Stage::GetCurrent().Add( offscreenCameraActor );
2098
2099   Material material = CreateMaterial();
2100   Image image = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
2101   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
2102   Integration::ResourceId imageRequestId = imageRequest->GetId();
2103   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
2104   material.AddTexture( image, "sTexture" );
2105
2106   Geometry geometry = CreateQuadGeometry();
2107   Renderer renderer = Renderer::New(geometry, material);
2108   Actor secondRootActor = Actor::New();
2109   secondRootActor.AddRenderer(renderer);
2110   secondRootActor.SetSize(100, 100);
2111   Stage::GetCurrent().Add(secondRootActor);
2112
2113   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, true);
2114   bool finished = false;
2115   RenderTaskFinished renderTaskFinished( finished );
2116   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2117   application.SendNotification();
2118
2119   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2120    DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2121    DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2122
2123    // FINISH RESOURCE LOADING - expect no rendering yet
2124    CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2125    DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2126    Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
2127    DALI_TEST_CHECK( lastSyncObj != NULL );
2128
2129    DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2130    application.GetPlatform().ClearReadyResources();
2131    sync.SetObjectSynced( lastSyncObj, true );
2132    DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,   finished, false, true  ) );
2133    DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
2134
2135    END_TEST;
2136 }
2137
2138 int UtcDaliRenderTaskOnce03(void)
2139 {
2140   TestApplication application;
2141
2142   tet_infoline("Testing RenderTask Render Once GlSync, using loading image. Switch from render always after ready to render once\n"
2143                "PRE: Render task ready, Image not loaded\n"
2144                "POST: Finished signal sent only once");
2145
2146   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2147   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2148   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
2149   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2150   drawTrace.Enable(true);
2151
2152   Actor rootActor = Actor::New();
2153   Stage::GetCurrent().Add( rootActor );
2154
2155   CameraActor offscreenCameraActor = CameraActor::New();
2156   Stage::GetCurrent().Add( offscreenCameraActor );
2157   ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
2158   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
2159   Integration::ResourceId imageRequestId = imageRequest->GetId();
2160   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
2161   Stage::GetCurrent().Add(secondRootActor);
2162
2163   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
2164   bool finished = false;
2165   RenderTaskFinished renderTaskFinished( finished );
2166   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2167   application.SendNotification();
2168
2169   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2170   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2171   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2172
2173   // FINISH RESOURCE LOADING
2174   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2175   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
2176   application.GetPlatform().ClearReadyResources();
2177   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
2178
2179   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2180   application.SendNotification(); //         Input,    Expected  Input,    Expected
2181   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2182   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
2183   DALI_TEST_CHECK( lastSyncObj != NULL );
2184
2185   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2186   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2187   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2188   sync.SetObjectSynced( lastSyncObj, true );
2189   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true  ) );
2190   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
2191
2192   END_TEST;
2193 }
2194
2195
2196 int UtcDaliRenderTaskOnce04(void)
2197 {
2198   TestApplication application;
2199   tet_infoline("Testing RenderTask Render Once GlSync, using Mesh which accesses texture through sampler with loading image.\n"
2200                "Switch from render always after ready to render once\n"
2201                "PRE: Render task ready, Image not loaded\n"
2202                "POST: Finished signal sent only once");
2203
2204   // SETUP AN OFFSCREEN RENDER TASK
2205   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2206   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
2207   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2208   drawTrace.Enable(true);
2209
2210   Actor rootActor = Actor::New();
2211   Stage::GetCurrent().Add( rootActor );
2212
2213   CameraActor offscreenCameraActor = CameraActor::New();
2214   Stage::GetCurrent().Add( offscreenCameraActor );
2215
2216   Material material = CreateMaterial();
2217   Image image = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
2218   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
2219   Integration::ResourceId imageRequestId = imageRequest->GetId();
2220   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
2221   material.AddTexture( image, "sTexture" );
2222
2223   Geometry geometry = CreateQuadGeometry();
2224   Renderer renderer = Renderer::New(geometry, material);
2225   Actor secondRootActor = Actor::New();
2226   secondRootActor.AddRenderer(renderer);
2227   secondRootActor.SetSize(100, 100);
2228   Stage::GetCurrent().Add(secondRootActor);
2229
2230   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
2231   bool finished = false;
2232   RenderTaskFinished renderTaskFinished( finished );
2233   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2234   application.SendNotification();
2235
2236   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2237   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2238   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2239
2240   // FINISH RESOURCE LOADING
2241   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2242   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
2243   application.GetPlatform().ClearReadyResources();
2244   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
2245
2246   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2247   application.SendNotification(); //         Input,    Expected  Input,    Expected
2248   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2249   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
2250   DALI_TEST_CHECK( lastSyncObj != NULL );
2251
2252   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2253   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2254   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2255   sync.SetObjectSynced( lastSyncObj, true );
2256   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true  ) );
2257   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
2258
2259   END_TEST;
2260 }
2261
2262 int UtcDaliRenderTaskOnce05(void)
2263 {
2264   TestApplication application;
2265
2266   tet_infoline("Testing RenderTask Render Once GlSync\n"
2267                "Switch from Render always after ready to render once with resources unready\n"
2268                "PRE: Everything ready to render\n"
2269                "POST: Finished signal sent once");
2270
2271   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2272   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2273   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
2274   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2275   drawTrace.Enable(true);
2276
2277   Actor rootActor = Actor::New();
2278   Stage::GetCurrent().Add( rootActor );
2279
2280   CameraActor offscreenCameraActor = CameraActor::New();
2281   Stage::GetCurrent().Add( offscreenCameraActor );
2282   ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
2283   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
2284   Integration::ResourceId imageRequestId = imageRequest->GetId();
2285   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
2286   Stage::GetCurrent().Add(secondRootActor);
2287
2288   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
2289   bool finished = false;
2290   RenderTaskFinished renderTaskFinished( finished );
2291   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2292   application.SendNotification();
2293
2294   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2295   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2296   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2297
2298   // CHANGE TO RENDER ONCE
2299   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2300   application.SendNotification(); //         Input,    Expected  Input,    Expected
2301   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2302   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2303
2304   // FINISH RESOURCE LOADING
2305   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2306   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2307   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
2308   DALI_TEST_CHECK( lastSyncObj != NULL );
2309   application.GetPlatform().ClearReadyResources();
2310
2311   sync.SetObjectSynced( lastSyncObj, true );
2312
2313   // Expect: No draw - we've just drawn our render task once, above. No finished signal -
2314   // we won't read the gl sync until the next frame. Continue rendering - we're waiting for
2315   // the sync
2316   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true  ) );
2317
2318   // Expect: 1 final draw - this Update doesn't update the scene, hence render instructions
2319   // from last frame but 1 are still present.
2320   // Finished signal should be true - we've just done the sync.
2321   // Should now stop rendering and updating - nothing left to do.
2322   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,   finished, true, false  ) );
2323
2324   END_TEST;
2325 }
2326
2327 #if 0
2328 //int UtcDaliRenderTaskOnce06(void)
2329 {
2330   TestApplication application;
2331
2332   tet_infoline("Testing RenderTask Render Once GlSync\n"
2333                "During RenderOnce, make ready resources unready before sending first finished signal\n"
2334                "PRE: Everything ready.\n"
2335                "POST: Finished signal sent only once");
2336
2337   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2338   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2339   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
2340   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2341   drawTrace.Enable(true);
2342
2343   Actor rootActor = Actor::New();
2344   Stage::GetCurrent().Add( rootActor );
2345
2346   CameraActor offscreenCameraActor = CameraActor::New();
2347   Stage::GetCurrent().Add( offscreenCameraActor );
2348   ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
2349   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
2350   Integration::ResourceId imageRequestId = imageRequest->GetId();
2351   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
2352   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2353   application.Render();
2354
2355   Stage::GetCurrent().Add(secondRootActor);
2356   application.GetPlatform().ClearReadyResources();
2357
2358   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
2359   bool finished = false;
2360   RenderTaskFinished renderTaskFinished( finished );
2361   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2362   application.SendNotification();
2363
2364   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2365   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2366   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2367
2368   // CHANGE TO RENDER ONCE, RESOURCES BECOME NOT READY
2369   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2370
2371   // Doesn't work...
2372   ReloadImage(application, secondRootActor.GetImage());
2373   application.SendNotification(); //         Input,    Expected  Input,    Expected
2374
2375   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2376   DALI_TEST_EQUALS( secondRootActor.GetImage().GetLoadingState(), Dali::ResourceLoading, TEST_LOCATION);
2377   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2378
2379   // FINISH RESOURCE LOADING
2380   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2381   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2382   application.GetPlatform().ClearReadyResources();
2383   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
2384   DALI_TEST_CHECK( lastSyncObj != NULL );
2385
2386   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2387   sync.SetObjectSynced( lastSyncObj, true );
2388   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true  ) );
2389   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, true  ) );
2390
2391   // Finished rendering - expect no more renders, no more signals:
2392   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2393   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2394   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2395   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2396   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2397   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2398   END_TEST;
2399 }
2400 #endif
2401
2402 int UtcDaliRenderTaskOnce07(void)
2403 {
2404   TestApplication application;
2405
2406   tet_infoline("Testing RenderTask Render Once GLSync\n"
2407                "Render once, Second call to SetRefreshRate(ONCE) triggers only one more finished signal\n"
2408                "PRE: Everything ready\n"
2409                "POST: exactly 1 finished signal per call to SetRefreshRate(ONCE)");
2410
2411   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2412   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2413   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
2414   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2415   drawTrace.Enable(true);
2416
2417   Actor rootActor = Actor::New();
2418   Stage::GetCurrent().Add( rootActor );
2419
2420   CameraActor offscreenCameraActor = CameraActor::New();
2421   Stage::GetCurrent().Add( offscreenCameraActor );
2422   ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
2423   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
2424   Integration::ResourceId imageRequestId = imageRequest->GetId();
2425   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
2426   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2427   application.Render();
2428   application.GetPlatform().ClearReadyResources();
2429
2430   Stage::GetCurrent().Add(secondRootActor);
2431
2432   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
2433   bool finished = false;
2434   RenderTaskFinished renderTaskFinished( finished );
2435   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2436   application.SendNotification();
2437
2438   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2439   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
2440
2441   // CHANGE TO RENDER ONCE,
2442   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2443   application.SendNotification();
2444   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2445   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
2446   DALI_TEST_CHECK( lastSyncObj != NULL );
2447
2448   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2449   sync.SetObjectSynced( lastSyncObj, true );
2450   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2451   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true,  false  ) );
2452
2453   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2454   application.SendNotification();
2455   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2456   lastSyncObj = sync.GetLastSyncObject();
2457   DALI_TEST_CHECK( lastSyncObj != NULL );
2458
2459   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2460   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2461   sync.SetObjectSynced( lastSyncObj, true );
2462   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2463   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
2464   END_TEST;
2465 }
2466
2467 int UtcDaliRenderTaskOnce08(void)
2468 {
2469   TestApplication application;
2470
2471   tet_infoline("Testing RenderTask Render Once GLSync\n"
2472                "Render once, Call to SetRefreshRate(ONCE) in Finished signal callback triggers "
2473                "another render & another finished signal\n"
2474                "PRE: Everything ready\n"
2475                "POST: exactly 1 finished signal per call to SetRefreshRate(ONCE)");
2476
2477
2478   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2479   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2480   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
2481   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2482   drawTrace.Enable(true);
2483
2484   Actor rootActor = Actor::New();
2485   Stage::GetCurrent().Add( rootActor );
2486
2487   CameraActor offscreenCameraActor = CameraActor::New();
2488   Stage::GetCurrent().Add( offscreenCameraActor );
2489   ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
2490   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
2491   Integration::ResourceId imageRequestId = imageRequest->GetId();
2492   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
2493   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2494   application.Render();
2495   application.GetPlatform().ClearReadyResources();
2496
2497   Stage::GetCurrent().Add(secondRootActor);
2498
2499   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
2500   bool finished = false;
2501
2502   ConnectionTracker connectionTracker;
2503   RenderTaskFinishedRenderAgain renderTaskFinishedRenderAgain( finished );
2504   newTask.FinishedSignal().Connect( &connectionTracker, renderTaskFinishedRenderAgain );
2505
2506   application.SendNotification();
2507
2508   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2509   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
2510   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
2511   DALI_TEST_CHECK( lastSyncObj == NULL );
2512
2513   // CHANGE TO RENDER ONCE,
2514   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2515   application.SendNotification();
2516   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2517   lastSyncObj = sync.GetLastSyncObject();
2518   DALI_TEST_CHECK( lastSyncObj != NULL );
2519
2520   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2521   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2522
2523   sync.SetObjectSynced( lastSyncObj, true );
2524   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2525   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
2526   application.SendNotification();
2527
2528   // Expect SetRefreshRate to have been called again
2529   // Prevent next finished signal calling refresh once again
2530   RenderTaskFinished renderTaskFinished( finished );
2531   connectionTracker.DisconnectAll();
2532   newTask.FinishedSignal().Connect( &connectionTracker, renderTaskFinished );
2533   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2534   lastSyncObj = sync.GetLastSyncObject();
2535   DALI_TEST_CHECK( lastSyncObj != NULL );
2536
2537   sync.SetObjectSynced( lastSyncObj, true );
2538   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2539   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
2540   END_TEST;
2541 }
2542
2543
2544 int UtcDaliRenderTaskOnce09(void)
2545 {
2546   TestApplication application;
2547
2548   tet_infoline("Testing RenderTask Render Once GlSync\n"
2549                "SetRefreshRate(ONCE) again before first finished signal has been sent.\n"
2550                "PRE: resources ready\n"
2551                "POST: Only 1 finished signal sent.");
2552
2553   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2554   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2555   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
2556   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2557   drawTrace.Enable(true);
2558
2559   Actor rootActor = Actor::New();
2560   Stage::GetCurrent().Add( rootActor );
2561
2562   CameraActor offscreenCameraActor = CameraActor::New();
2563   Stage::GetCurrent().Add( offscreenCameraActor );
2564   ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
2565   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
2566   Integration::ResourceId imageRequestId = imageRequest->GetId();
2567   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
2568   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2569   application.Render();
2570   application.GetPlatform().ClearReadyResources();
2571
2572   Stage::GetCurrent().Add(secondRootActor);
2573
2574   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
2575   bool finished = false;
2576   RenderTaskFinished renderTaskFinished( finished );
2577   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2578   application.SendNotification();
2579
2580   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2581   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
2582
2583   // CHANGE TO RENDER ONCE,
2584   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2585   application.SendNotification();
2586   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2587   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2588   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2589
2590   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2591   application.SendNotification();
2592   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2593   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
2594   DALI_TEST_CHECK( lastSyncObj != NULL );
2595
2596   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2597   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2598   sync.SetObjectSynced( lastSyncObj, true );
2599   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2600   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
2601
2602   END_TEST;
2603 }
2604
2605 int UtcDaliRenderTaskOnce10(void)
2606 {
2607   TestApplication application;
2608
2609   tet_infoline("Testing RenderTask Render Once GlSync\n"
2610                "SetRefreshRate(ONCE), resource load failed completes render task.\n"
2611                "PRE: resources not ready\n"
2612                "POST: Only 1 finished signal sent.");
2613
2614   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2615   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2616   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
2617   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2618   drawTrace.Enable(true);
2619
2620   Actor rootActor = Actor::New();
2621   Stage::GetCurrent().Add( rootActor );
2622
2623   CameraActor offscreenCameraActor = CameraActor::New();
2624   Stage::GetCurrent().Add( offscreenCameraActor );
2625   ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
2626   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
2627   Integration::ResourceId imageRequestId = imageRequest->GetId();
2628   Stage::GetCurrent().Add(secondRootActor);
2629
2630   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
2631   bool finished = false;
2632   RenderTaskFinished renderTaskFinished( finished );
2633   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2634   application.SendNotification();
2635
2636   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2637   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2638   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2639
2640   // CHANGE TO RENDER ONCE,
2641   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2642   application.SendNotification();
2643   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2644   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2645   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2646
2647   tet_printf("  FailImageLoad\n");
2648
2649   FailImageLoad(application, imageRequestId); // Need to run Update again for this to complete
2650
2651   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) ); // nothing to draw
2652   application.SendNotification();
2653
2654   // Drawing empty framebuffer, so will still get a GL sync
2655   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
2656   DALI_TEST_CHECK( lastSyncObj != NULL );
2657
2658   sync.SetObjectSynced( lastSyncObj, true );
2659
2660   // Expect finished signal, as all resources are complete
2661   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2662   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
2663
2664   END_TEST;
2665 }
2666
2667 int UtcDaliRenderTaskOnceNoSync01(void)
2668 {
2669   TestApplication application;
2670
2671   tet_infoline("Testing RenderTask Render Once, using loading image\nPRE: Resources not ready, Source not visible\nPOST: Finished signal sent once only");
2672
2673   // SETUP AN OFFSCREEN RENDER TASK
2674   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2675   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2676   drawTrace.Enable(true);
2677
2678   Actor rootActor = Actor::New();
2679   Stage::GetCurrent().Add( rootActor );
2680
2681   CameraActor offscreenCameraActor = CameraActor::New();
2682   Stage::GetCurrent().Add( offscreenCameraActor );
2683   ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
2684   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
2685   Integration::ResourceId imageRequestId = imageRequest->GetId();
2686   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
2687
2688   Stage::GetCurrent().Add(secondRootActor);
2689
2690   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, false);
2691   bool finished = false;
2692   RenderTaskFinished renderTaskFinished( finished );
2693   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2694   application.SendNotification();
2695
2696   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2697   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2698   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2699
2700   // FINISH RESOURCE LOADING - expect immediate rendering yet
2701   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2702   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2703   application.GetPlatform().ClearReadyResources();
2704   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false ) );
2705   END_TEST;
2706 }
2707
2708 int UtcDaliRenderTaskOnceNoSync02(void)
2709 {
2710   TestApplication application;
2711
2712   tet_infoline("Testing RenderTask Render Once, using Mesh which accesses texture through sampler with loading image.\n"
2713                "PRE: Resources not ready\nPOST: Finished signal sent once only");
2714   // SETUP AN OFFSCREEN RENDER TASK
2715   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2716   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2717   drawTrace.Enable(true);
2718
2719   Actor rootActor = Actor::New();
2720   Stage::GetCurrent().Add( rootActor );
2721
2722   CameraActor offscreenCameraActor = CameraActor::New();
2723   Stage::GetCurrent().Add( offscreenCameraActor );
2724
2725   Material material = CreateMaterial();
2726   Image image = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
2727   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
2728   Integration::ResourceId imageRequestId = imageRequest->GetId();
2729   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
2730   material.AddTexture(image, "sTexture" );
2731
2732   Geometry geometry = CreateQuadGeometry();
2733   Renderer renderer = Renderer::New(geometry, material);
2734   Actor secondRootActor = Actor::New();
2735   secondRootActor.AddRenderer(renderer);
2736   secondRootActor.SetSize(100, 100);
2737   Stage::GetCurrent().Add(secondRootActor);
2738
2739   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, false);
2740   bool finished = false;
2741   RenderTaskFinished renderTaskFinished( finished );
2742   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2743   application.SendNotification();
2744
2745   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2746   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2747   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2748
2749   // FINISH RESOURCE LOADING - expect immediate rendering yet
2750   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2751   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2752   application.GetPlatform().ClearReadyResources();
2753   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false ) );
2754
2755   END_TEST;
2756 }
2757
2758 int UtcDaliRenderTaskOnceNoSync03(void)
2759 {
2760   TestApplication application;
2761
2762   tet_infoline("Testing RenderTask Render Once, using loading image. Switch from render always after ready to render once\n"
2763                "PRE: Render task ready, Image not loaded\n"
2764                "POST: Finished signal sent only once");
2765
2766   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2767   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2768   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2769   drawTrace.Enable(true);
2770
2771   Actor rootActor = Actor::New();
2772   Stage::GetCurrent().Add( rootActor );
2773
2774   CameraActor offscreenCameraActor = CameraActor::New();
2775   Stage::GetCurrent().Add( offscreenCameraActor );
2776   ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
2777   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
2778   Integration::ResourceId imageRequestId = imageRequest->GetId();
2779   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
2780   Stage::GetCurrent().Add(secondRootActor);
2781
2782   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
2783   bool finished = false;
2784   RenderTaskFinished renderTaskFinished( finished );
2785   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2786   application.SendNotification();
2787
2788   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2789   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2790   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2791
2792   // FINISH RESOURCE LOADING
2793   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2794   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
2795   application.GetPlatform().ClearReadyResources();
2796
2797   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2798   application.SendNotification(); //         Input,    Expected  Input,    Expected
2799   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2800   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
2801   END_TEST;
2802 }
2803
2804 int UtcDaliRenderTaskOnceNoSync04(void)
2805 {
2806   TestApplication application;
2807
2808   tet_infoline("Testing RenderTask Render Once, using Mesh which accesses texture through sampler with loading image.\n"
2809                "Switch from render always after ready to render once\n"
2810                "PRE: Render task ready, Image not loaded\n"
2811                "POST: Finished signal sent only once");
2812
2813   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2814   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2815   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2816   drawTrace.Enable(true);
2817
2818   Actor rootActor = Actor::New();
2819   Stage::GetCurrent().Add( rootActor );
2820
2821   CameraActor offscreenCameraActor = CameraActor::New();
2822   Stage::GetCurrent().Add( offscreenCameraActor );
2823
2824   Material material = CreateMaterial();
2825   Image image = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
2826   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
2827   Integration::ResourceId imageRequestId = imageRequest->GetId();
2828   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
2829   material.AddTexture( image, "sTexture" );
2830
2831   Geometry geometry = CreateQuadGeometry();
2832   Renderer renderer = Renderer::New(geometry, material);
2833   Actor secondRootActor = Actor::New();
2834   secondRootActor.AddRenderer(renderer);
2835   secondRootActor.SetSize(100, 100);
2836   Stage::GetCurrent().Add(secondRootActor);
2837
2838
2839   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
2840   bool finished = false;
2841   RenderTaskFinished renderTaskFinished( finished );
2842   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2843   application.SendNotification();
2844
2845   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2846   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2847   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2848
2849   // FINISH RESOURCE LOADING
2850   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2851   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
2852   application.GetPlatform().ClearReadyResources();
2853
2854   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2855   application.SendNotification(); //         Input,    Expected  Input,    Expected
2856   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2857   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
2858   END_TEST;
2859 }
2860
2861 int UtcDaliRenderTaskOnceNoSync05(void)
2862 {
2863   TestApplication application;
2864
2865   tet_infoline("Testing RenderTask Render Once\n"
2866                "Switch from Render always after ready to render once with resources unready\n"
2867                "PRE: Everything ready to render\n"
2868                "POST: Finished signal sent once");
2869
2870   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2871   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2872   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2873   drawTrace.Enable(true);
2874
2875   Actor rootActor = Actor::New();
2876   Stage::GetCurrent().Add( rootActor );
2877
2878   CameraActor offscreenCameraActor = CameraActor::New();
2879   Stage::GetCurrent().Add( offscreenCameraActor );
2880   ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
2881   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
2882   Integration::ResourceId imageRequestId = imageRequest->GetId();
2883   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
2884   Stage::GetCurrent().Add(secondRootActor);
2885
2886   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
2887   bool finished = false;
2888   RenderTaskFinished renderTaskFinished( finished );
2889   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2890   application.SendNotification();
2891
2892   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2893   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2894   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2895
2896   // CHANGE TO RENDER ONCE
2897   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2898   application.SendNotification(); //         Input,    Expected  Input,    Expected
2899   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2900   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2901
2902   // FINISH RESOURCE LOADING
2903   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2904   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2905   application.GetPlatform().ClearReadyResources();
2906   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true, false  ) );
2907   END_TEST;
2908 }
2909
2910 #if 0
2911 //int UtcDaliRenderTaskOnceNoSync06(void)
2912 {
2913   TestApplication application;
2914
2915   tet_infoline("Testing RenderTask Render Once\n"
2916                "During RenderOnce, make ready resources unready before sending first finished signal\n"
2917                "PRE: Everything ready.\n"
2918                "POST: Finished signal sent only once");
2919
2920   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2921   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2922   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2923   drawTrace.Enable(true);
2924
2925   Actor rootActor = Actor::New();
2926   Stage::GetCurrent().Add( rootActor );
2927
2928   CameraActor offscreenCameraActor = CameraActor::New();
2929   Stage::GetCurrent().Add( offscreenCameraActor );
2930   ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
2931   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
2932   Integration::ResourceId imageRequestId = imageRequest->GetId();
2933   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
2934   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2935   application.Render();
2936   application.GetPlatform().ClearReadyResources();
2937
2938   Stage::GetCurrent().Add(secondRootActor);
2939
2940   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
2941   bool finished = false;
2942   RenderTaskFinished renderTaskFinished( finished );
2943   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
2944   application.SendNotification();
2945
2946   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
2947   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
2948   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
2949
2950   // CHANGE TO RENDER ONCE, RESOURCES BECOME NOT READY
2951   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
2952
2953   // Doesn't work...
2954   ReloadImage(application, secondRootActor.GetImage());
2955   application.SendNotification(); //         Input,    Expected  Input,    Expected
2956
2957   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2958   DALI_TEST_EQUALS( secondRootActor.GetImage().GetLoadingState(), Dali::ResourceLoading, TEST_LOCATION);
2959   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
2960
2961   // FINISH RESOURCE LOADING
2962   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2963   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, true, true ) );
2964   application.GetPlatform().ClearReadyResources();
2965   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2966   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true  ) );
2967   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2968   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, false, true ) );
2969   END_TEST;
2970 }
2971 #endif
2972
2973 int UtcDaliRenderTaskOnceNoSync07(void)
2974 {
2975   TestApplication application;
2976
2977   tet_infoline("Testing RenderTask Render Once\n"
2978                "Render once, Second call to SetRefreshRate(ONCE) triggers only one more finished signal\n"
2979                "PRE: Everything ready\n"
2980                "POST: exactly 1 finished signal per call to SetRefreshRate(ONCE)");
2981
2982   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
2983   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2984   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
2985   drawTrace.Enable(true);
2986
2987   Actor rootActor = Actor::New();
2988   Stage::GetCurrent().Add( rootActor );
2989
2990   CameraActor offscreenCameraActor = CameraActor::New();
2991   Stage::GetCurrent().Add( offscreenCameraActor );
2992   ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
2993   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
2994   Integration::ResourceId imageRequestId = imageRequest->GetId();
2995   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
2996   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
2997   application.Render();
2998   application.GetPlatform().ClearReadyResources();
2999
3000   Stage::GetCurrent().Add(secondRootActor);
3001
3002   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
3003   bool finished = false;
3004   RenderTaskFinished renderTaskFinished( finished );
3005   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
3006   application.SendNotification();
3007
3008   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
3009   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
3010
3011   // CHANGE TO RENDER ONCE,
3012   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
3013   application.SendNotification();
3014   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
3015   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true,  false ) );
3016
3017   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
3018   application.SendNotification();
3019   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
3020   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true,  false ) );
3021   END_TEST;
3022 }
3023
3024 int UtcDaliRenderTaskOnceNoSync08(void)
3025 {
3026   TestApplication application;
3027
3028   tet_infoline("Testing RenderTask Render Once\n"
3029                "Render once, Call to SetRefreshRate(ONCE) in Finished signal callback triggers\n"
3030                "another render & another finished signal\n"
3031                "PRE: Everything ready\n"
3032                "POST: exactly 1 finished signal per call to SetRefreshRate(ONCE)");
3033
3034
3035   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
3036   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
3037   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
3038   drawTrace.Enable(true);
3039
3040   Actor rootActor = Actor::New();
3041   Stage::GetCurrent().Add( rootActor );
3042
3043   CameraActor offscreenCameraActor = CameraActor::New();
3044   Stage::GetCurrent().Add( offscreenCameraActor );
3045   ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
3046   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
3047   Integration::ResourceId imageRequestId = imageRequest->GetId();
3048   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
3049   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
3050   application.Render();
3051   application.GetPlatform().ClearReadyResources();
3052
3053   Stage::GetCurrent().Add(secondRootActor);
3054
3055   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
3056   bool finished = false;
3057
3058   ConnectionTracker connectionTracker;
3059   RenderTaskFinishedRenderAgain renderTaskFinishedRenderAgain( finished );
3060   newTask.FinishedSignal().Connect( &connectionTracker, renderTaskFinishedRenderAgain );
3061
3062   application.SendNotification();
3063
3064   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
3065   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
3066
3067   // CHANGE TO RENDER ONCE,
3068   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
3069   application.SendNotification();
3070   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
3071   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true,  false ) );
3072
3073   // Expect SetRefreshRate to have been called again
3074   // Prevent next finished signal calling refresh once again
3075   RenderTaskFinished renderTaskFinished( finished );
3076   connectionTracker.DisconnectAll();
3077   newTask.FinishedSignal().Connect( &connectionTracker, renderTaskFinished );
3078
3079   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
3080   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true,  false ) );
3081   END_TEST;
3082 }
3083
3084
3085 int UtcDaliRenderTaskOnceNoSync09(void)
3086 {
3087   TestApplication application;
3088
3089   tet_infoline("Testing RenderTask Render Once\n"
3090                "SetRefreshRate(ONCE) again before first finished signal has been sent.\n"
3091                "PRE: resources ready\n"
3092                "POST: Only 1 finished signal sent.");
3093
3094   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
3095   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
3096   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
3097   drawTrace.Enable(true);
3098
3099   Actor rootActor = Actor::New();
3100   Stage::GetCurrent().Add( rootActor );
3101
3102   CameraActor offscreenCameraActor = CameraActor::New();
3103   Stage::GetCurrent().Add( offscreenCameraActor );
3104   ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
3105   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
3106   Integration::ResourceId imageRequestId = imageRequest->GetId();
3107   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
3108   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
3109   application.Render();
3110   application.GetPlatform().ClearReadyResources();
3111
3112   Stage::GetCurrent().Add(secondRootActor);
3113
3114   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
3115   bool finished = false;
3116   RenderTaskFinished renderTaskFinished( finished );
3117   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
3118   application.SendNotification();
3119
3120   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
3121   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, false ) );
3122
3123   // CHANGE TO RENDER ONCE,
3124   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
3125   application.SendNotification();
3126   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
3127   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true,  false ) );
3128
3129   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
3130   application.SendNotification();
3131   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,    finished, false, true ) );
3132   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,   finished, true,  false ) );
3133   END_TEST;
3134 }
3135
3136 int UtcDaliRenderTaskOnceNoSync10(void)
3137 {
3138   TestApplication application;
3139
3140   tet_infoline("Testing RenderTask Render Once\n"
3141                "SetRefreshRate(ONCE), resource load failed, completes render task.\n"
3142                "PRE: resources not ready\n"
3143                "POST: Only 1 finished signal sent.");
3144
3145   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
3146   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
3147   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
3148   drawTrace.Enable(true);
3149
3150   Actor rootActor = Actor::New();
3151   Stage::GetCurrent().Add( rootActor );
3152
3153   CameraActor offscreenCameraActor = CameraActor::New();
3154   Stage::GetCurrent().Add( offscreenCameraActor );
3155   ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
3156   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
3157   Integration::ResourceId imageRequestId = imageRequest->GetId();
3158   Stage::GetCurrent().Add(secondRootActor);
3159
3160   RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
3161   bool finished = false;
3162   RenderTaskFinished renderTaskFinished( finished );
3163   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
3164   application.SendNotification();
3165
3166   // START PROCESS/RENDER                    Input,     Expected  Input,    Expected
3167   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
3168   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
3169
3170   // CHANGE TO RENDER ONCE,
3171   newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
3172   application.SendNotification();
3173   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
3174   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
3175   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) );
3176
3177   FailImageLoad(application, imageRequestId); // Need to run Update again for this to complete
3178   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, false, true ) ); // nothing to draw
3179   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,    finished, true,  false  ) );
3180
3181   END_TEST;
3182 }
3183
3184
3185
3186 int UtcDaliRenderTaskOnceChain01(void)
3187 {
3188   TestApplication application;
3189
3190   tet_infoline("Testing RenderTask Render Once Chained render tasks\n"
3191                "SetRefreshRate(ONCE), resource load completes, both render tasks render.\n"
3192                "PRE: resources not ready\n"
3193                "POST: 2 finished signals sent.");
3194
3195   // SETUP A CONTINUOUS OFFSCREEN RENDER TASK
3196   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
3197   TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
3198   drawTrace.Enable(true);
3199
3200   Actor defaultRootActor = Actor::New(); // Root for default RT
3201   Stage::GetCurrent().Add( defaultRootActor );
3202
3203   CameraActor offscreenCameraActor = CameraActor::New();
3204   Stage::GetCurrent().Add( offscreenCameraActor );
3205   ImageActor firstRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
3206   Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
3207   Integration::ResourceId imageRequestId = imageRequest->GetId();
3208   Integration::ResourceTypeId imageType  = imageRequest->GetType()->id;
3209   Stage::GetCurrent().Add(firstRootActor);
3210
3211   // first render task
3212   RenderTask firstTask = CreateRenderTask(application, offscreenCameraActor, defaultRootActor, firstRootActor, RenderTask::REFRESH_ONCE, false);
3213   bool firstFinished = false;
3214   RenderTaskFinished renderTask1Finished( firstFinished );
3215   firstTask.FinishedSignal().Connect( &application, renderTask1Finished );
3216
3217   // Second render task
3218   FrameBufferImage fbo = firstTask.GetTargetFrameBuffer();
3219   ImageActor secondRootActor = ImageActor::New( fbo );
3220   Stage::GetCurrent().Add(secondRootActor);
3221   RenderTask secondTask = CreateRenderTask(application, offscreenCameraActor, defaultRootActor, secondRootActor, RenderTask::REFRESH_ONCE, false);
3222   bool secondFinished = false;
3223   RenderTaskFinished renderTask2Finished( secondFinished );
3224   secondTask.FinishedSignal().Connect( &application, renderTask2Finished );
3225
3226   application.SendNotification();
3227
3228   // START PROCESS/RENDER                    Input,    Expected  Input,    Expected
3229   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,  firstFinished, false, true ) );
3230   DALI_TEST_CHECK( secondFinished == false );
3231   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,  firstFinished, false, true ) );
3232   DALI_TEST_CHECK( secondFinished == false );
3233
3234   CompleteImageLoad(application, imageRequestId, imageType); // Need to run update again for this to complete
3235   DALI_TEST_CHECK( UpdateRender(application, drawTrace, true,  firstFinished, false, true ) );
3236   DALI_TEST_CHECK( secondFinished == false );
3237   application.GetPlatform().ClearReadyResources();
3238
3239   DALI_TEST_CHECK( UpdateRender(application, drawTrace, false,  firstFinished, true,  false ) );
3240   DALI_TEST_CHECK( secondFinished == true );
3241
3242   END_TEST;
3243 }
3244
3245 int UtcDaliRenderTaskProperties(void)
3246 {
3247   TestApplication application;
3248
3249   RenderTask task = Stage::GetCurrent().GetRenderTaskList().CreateTask();
3250
3251   Property::IndexContainer indices;
3252   task.GetPropertyIndices( indices );
3253   DALI_TEST_CHECK( indices.Size() );
3254   DALI_TEST_EQUALS( indices.Size(), task.GetPropertyCount(), TEST_LOCATION );
3255   END_TEST;
3256 }
3257
3258 int UtcDaliRenderTaskSetScreenToFrameBufferMappingActor(void)
3259 {
3260   TestApplication application;
3261   tet_infoline("Testing RenderTask::SetScreenToFrameBufferMappingActor ");
3262
3263   Stage stage = Stage::GetCurrent();
3264   Size stageSize = stage.GetSize();
3265   Actor mappingActor = Actor::New();
3266   Vector2 scale( 0.6f, 0.75f);
3267   Vector2 offset( stageSize.x*0.1f, stageSize.y*0.15f);
3268   mappingActor.SetSize( stageSize * scale );
3269   mappingActor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
3270   mappingActor.SetPosition( offset.x, offset.y );
3271   stage.Add( mappingActor );
3272
3273   Actor offscreenActor = Actor::New();
3274   offscreenActor.SetSize( stageSize );
3275   offscreenActor.SetAnchorPoint( AnchorPoint::TOP_LEFT );
3276   stage.Add( offscreenActor );
3277
3278   RenderTaskList taskList = stage.GetRenderTaskList();
3279   RenderTask renderTask = taskList.CreateTask();
3280   FrameBufferImage frameBufferImage =  FrameBufferImage::New(stageSize.width*scale.x, stageSize.height*scale.y, Pixel::A8, Image::NEVER);
3281   renderTask.SetSourceActor( offscreenActor );
3282   renderTask.SetExclusive( true );
3283   renderTask.SetInputEnabled( true );
3284   renderTask.SetTargetFrameBuffer( frameBufferImage );
3285   renderTask.SetRefreshRate( RenderTask::REFRESH_ONCE );
3286   renderTask.SetScreenToFrameBufferMappingActor( mappingActor );
3287   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
3288
3289   // Render and notify
3290   application.SendNotification();
3291   application.Render();
3292   application.Render();
3293   application.SendNotification();
3294
3295   Vector2 screenCoordinates( stageSize.x * 0.05f, stageSize.y * 0.05f );
3296   Dali::HitTestAlgorithm::Results results;
3297   DALI_TEST_CHECK( !results.actor );
3298   DALI_TEST_EQUALS( Vector2::ZERO, results.actorCoordinates, 0.1f, TEST_LOCATION );
3299   // miss expected, results not changed
3300   DALI_TEST_CHECK( false == Dali::HitTestAlgorithm::HitTest( renderTask, screenCoordinates, results, IsActorHittableFunction ) );
3301   DALI_TEST_CHECK( !results.actor );
3302   DALI_TEST_EQUALS( Vector2::ZERO, results.actorCoordinates, 0.1f, TEST_LOCATION );
3303
3304   screenCoordinates.x = stageSize.x * 0.265f;
3305   screenCoordinates.y = stageSize.y * 0.33f;
3306   results.actor = Actor();
3307   results.actorCoordinates = Vector2::ZERO;
3308   // hit expected, results changed
3309   DALI_TEST_CHECK( true == Dali::HitTestAlgorithm::HitTest( renderTask, screenCoordinates, results, IsActorHittableFunction ) );
3310   DALI_TEST_CHECK( results.actor  == offscreenActor );
3311   DALI_TEST_EQUALS( (screenCoordinates-offset)/scale , results.actorCoordinates, 0.1f, TEST_LOCATION );
3312
3313   screenCoordinates.x = stageSize.x * 0.435f;
3314   screenCoordinates.y = stageSize.y * 0.52f;
3315   // hit expected, results changed
3316   DALI_TEST_CHECK( true == Dali::HitTestAlgorithm::HitTest( renderTask, screenCoordinates, results, IsActorHittableFunction ) );
3317   DALI_TEST_CHECK( results.actor  == offscreenActor );
3318   const Vector2 expectedCoordinates = (screenCoordinates-offset)/scale;
3319   DALI_TEST_EQUALS( expectedCoordinates , results.actorCoordinates, 0.1f, TEST_LOCATION );
3320
3321   screenCoordinates.x = stageSize.x * 0.65f;
3322   screenCoordinates.y = stageSize.y * 0.95f;
3323   // miss expected, results not changed
3324   DALI_TEST_CHECK( false == Dali::HitTestAlgorithm::HitTest( renderTask, screenCoordinates, results, IsActorHittableFunction ) );
3325   DALI_TEST_CHECK( results.actor  == offscreenActor );
3326   DALI_TEST_EQUALS( expectedCoordinates , results.actorCoordinates, 0.1f, TEST_LOCATION );
3327   END_TEST;
3328 }
3329
3330 int UtcDaliRenderTaskFinishInvisibleSourceActor(void)
3331 {
3332   TestApplication application;
3333
3334   tet_infoline("Testing RenderTask::SignalFinished()");
3335
3336   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
3337   TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
3338
3339   CameraActor offscreenCameraActor = CameraActor::New();
3340
3341   Stage::GetCurrent().Add( offscreenCameraActor );
3342
3343   BufferImage image = BufferImage::New( 10, 10 );
3344   ImageActor rootActor = ImageActor::New( image );
3345   rootActor.SetSize( 10, 10 );
3346   rootActor.SetVisible(false);
3347   Stage::GetCurrent().Add( rootActor );
3348
3349   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
3350   NativeImageInterfacePtr testNativeImagePtr = TestNativeImage::New(10, 10);
3351   FrameBufferImage frameBufferImage = FrameBufferImage::New( *testNativeImagePtr.Get() );
3352
3353   // Flush all outstanding messages
3354   application.SendNotification();
3355   application.Render();
3356
3357   RenderTask newTask = taskList.CreateTask();
3358   newTask.SetCameraActor( offscreenCameraActor );
3359   newTask.SetSourceActor( rootActor );
3360   newTask.SetInputEnabled( false );
3361   newTask.SetClearColor( Vector4( 0.f, 0.f, 0.f, 0.f ) );
3362   newTask.SetClearEnabled( true );
3363   newTask.SetExclusive( true );
3364   newTask.SetRefreshRate( RenderTask::REFRESH_ONCE );
3365   newTask.SetTargetFrameBuffer( frameBufferImage );
3366
3367   // Framebuffer doesn't actually get created until Connected, i.e. by previous line
3368
3369   bool finished = false;
3370   RenderTaskFinished renderTaskFinished( finished );
3371   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
3372
3373   // Flush the queue and render.
3374   application.SendNotification();
3375
3376   // 1 render to process render task, then wait for sync before finished msg is sent
3377   // from update to the event thread.
3378
3379   application.Render();
3380   application.SendNotification();
3381   DALI_TEST_CHECK( !finished );
3382
3383   Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
3384   DALI_TEST_CHECK( lastSyncObj != NULL );
3385
3386   application.Render();
3387   DALI_TEST_EQUALS( (Integration::KeepUpdating::Reasons)(application.GetUpdateStatus() & Integration::KeepUpdating::RENDER_TASK_SYNC), Integration::KeepUpdating::RENDER_TASK_SYNC, TEST_LOCATION );
3388   application.SendNotification();
3389   DALI_TEST_CHECK( !finished );
3390
3391   application.Render();
3392   DALI_TEST_EQUALS( (Integration::KeepUpdating::Reasons)(application.GetUpdateStatus() & Integration::KeepUpdating::RENDER_TASK_SYNC), Integration::KeepUpdating::RENDER_TASK_SYNC, TEST_LOCATION );
3393   application.SendNotification();
3394   DALI_TEST_CHECK( ! finished );
3395
3396   sync.SetObjectSynced( lastSyncObj, true );
3397
3398   application.Render();
3399   application.SendNotification();
3400   DALI_TEST_CHECK( !finished );
3401
3402   application.Render();
3403   application.SendNotification();
3404   DALI_TEST_CHECK( finished );
3405   finished = false;
3406
3407   application.Render(); // Double check no more finished signal
3408   application.SendNotification();
3409   DALI_TEST_CHECK( ! finished );
3410
3411   END_TEST;
3412 }
3413
3414 int UtcDaliRenderTaskFinishMissingImage(void)
3415 {
3416   TestApplication application;
3417
3418   // Previously we had bugs where not having a resource ID would cause render-tasks to wait forever
3419   tet_infoline("Testing RenderTask::SignalFinished() when an ImageActor has no Image set");
3420
3421   Stage stage = Stage::GetCurrent();
3422
3423   BufferImage image = BufferImage::New( 10, 10 );
3424   ImageActor rootActor = ImageActor::New( image );
3425   rootActor.SetSize( 10, 10 );
3426   stage.Add( rootActor );
3427
3428   ImageActor actorWithMissingImage = ImageActor::New( Image() );
3429   actorWithMissingImage.SetSize( 10, 10 );
3430   stage.Add( actorWithMissingImage );
3431
3432   RenderTaskList taskList = Stage::GetCurrent().GetRenderTaskList();
3433   RenderTask newTask = taskList.CreateTask();
3434   newTask.SetInputEnabled( false );
3435   newTask.SetClearColor( Vector4( 0.f, 0.f, 0.f, 0.f ) );
3436   newTask.SetClearEnabled( true );
3437   newTask.SetExclusive( true );
3438   newTask.SetRefreshRate( RenderTask::REFRESH_ONCE );
3439
3440   bool finished = false;
3441   RenderTaskFinished renderTaskFinished( finished );
3442   newTask.FinishedSignal().Connect( &application, renderTaskFinished );
3443
3444   // 1 render to process render task, then 1 before finished msg is sent from update to the event thread.
3445   application.SendNotification();
3446   application.Render();
3447   application.Render();
3448
3449   application.SendNotification();
3450   DALI_TEST_CHECK( finished );
3451
3452   END_TEST;
3453 }