automated-tests/src/dali/utc-Dali-RenderableActor.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
  23 #include <dali/integration-api/events/touch-event-integ.h>
  24 #include <dali-test-suite-utils.h>
  25
  26 using namespace Dali;
  27
  28 void renderable_actor_startup(void)
  29 {
  30   test_return_value = TET_UNDEF;
  31 }
  32
  33 void renderable_actor_cleanup(void)
  34 {
  35   test_return_value = TET_PASS;
  36 }
  37
  38 namespace
  39 {
  40
  41 static bool gIsActor1SortModifierCorrect;
  42 static bool gIsActor2SortModifierCorrect;
  43 const float gActor1SortModifierValue = 96.0f;
  44 const float gActor2SortModifierValue = 53.0f;
  45
  46 static float TestSortFunction(const Vector3& position, float sortModifier)
  47 {
  48   if ( fabs(sortModifier - gActor1SortModifierValue) < 0.01)
  49     gIsActor1SortModifierCorrect = true;
  50
  51   if ( fabs(sortModifier - gActor2SortModifierValue) < 0.01)
  52     gIsActor2SortModifierCorrect = true;
  53
  54   return 0.0f;
  55 }
  56
  57 } // anon namespace
  58
  59 int UtcDaliRenderableActorDownCast(void)
  60 {
  61   TestApplication application;
  62
  63   tet_infoline("Testing Dali::RenderableActor::DownCast()");
  64
  65   ImageActor imageActor = ImageActor::New();
  66
  67   Actor anActor = Actor::New();
  68   anActor.Add( imageActor );
  69
  70   Actor child = anActor.GetChildAt(0);
  71   RenderableActor renderableActor = RenderableActor::DownCast( child );
  72   DALI_TEST_CHECK( renderableActor );
  73
  74   renderableActor.Reset();
  75   DALI_TEST_CHECK( !renderableActor );
  76
  77   renderableActor = DownCast< RenderableActor >( child );
  78   DALI_TEST_CHECK( renderableActor );
  79
  80   renderableActor = DownCast< RenderableActor >( anActor );
  81   DALI_TEST_CHECK( !renderableActor );
  82
  83   Actor unInitialzedActor;
  84   renderableActor = RenderableActor::DownCast( unInitialzedActor );
  85   DALI_TEST_CHECK( !renderableActor );
  86
  87   renderableActor = DownCast< RenderableActor >( unInitialzedActor );
  88   DALI_TEST_CHECK( !renderableActor );
  89   END_TEST;
  90 }
  91
  92 int UtcDaliRenderableActorSetSortModifier(void)
  93 {
  94   TestApplication application;
  95
  96   tet_infoline("Testing Dali::RenderableActor::SetSortModifier()");
  97
  98   float val = -500.0f;
  99
 100   ImageActor actor = ImageActor::New();
 101   Stage::GetCurrent().Add(actor);
 102
 103   actor.SetSortModifier( val );
 104
 105   float returnValue = actor.GetSortModifier();
 106
 107   //Verify through actor api
 108   DALI_TEST_EQUALS(returnValue, val, TEST_LOCATION);
 109
 110   Stage::GetCurrent().Remove(actor);
 111
 112
 113   //Verify through layer SetSortFunction
 114   gIsActor1SortModifierCorrect = false;
 115   gIsActor2SortModifierCorrect = false;
 116   BufferImage img = BufferImage::New( 1,1 );
 117   // create two transparent actors so there is something to sort
 118   ImageActor actor1 = ImageActor::New( img );
 119   ImageActor actor2 = ImageActor::New( img );
 120   actor1.SetSize(1,1);
 121   actor1.SetPosition( 0, 0, 0);
 122   actor1.SetSortModifier( gActor1SortModifierValue );
 123   actor1.SetColor( Vector4(1, 1, 1, 0.5f ) ); // 50% transparent
 124   actor2.SetSize(1,1);
 125   actor2.SetPosition( 0, 0, 1);
 126   actor2.SetSortModifier( gActor2SortModifierValue );
 127   actor2.SetColor( Vector4(1, 1, 1, 0.5f ) ); // 50% transparent
 128
 129   // add to stage
 130    Stage::GetCurrent().Add( actor1 );
 131    Stage::GetCurrent().Add( actor2 );
 132
 133    Layer root = Stage::GetCurrent().GetLayer( 0 );
 134    root.SetSortFunction( TestSortFunction );
 135
 136    // flush the queue and render once
 137    application.SendNotification();
 138    application.Render();
 139
 140    DALI_TEST_CHECK( gIsActor1SortModifierCorrect && gIsActor2SortModifierCorrect );
 141    END_TEST;
 142
 143 }
 144
 145 int UtcDaliRenderableActorGetSortModifier(void)
 146 {
 147   TestApplication application;
 148
 149   tet_infoline("Testing Dali::RenderableActor::GetSortModifier()");
 150
 151   ImageActor actor = ImageActor::New();
 152   Stage::GetCurrent().Add(actor);
 153
 154   DALI_TEST_EQUALS(actor.GetSortModifier(), 0.0f, TEST_LOCATION);
 155
 156   Stage::GetCurrent().Remove(actor);
 157   END_TEST;
 158 }
 159
 160 int UtcDaliRenderableActorSetGetBlendMode(void)
 161 {
 162   TestApplication application;
 163
 164   tet_infoline("Testing Dali::RenderableActor::SetBlendMode() / Dali::RenderableActor::GetBlendMode()");
 165
 166   ImageActor actor = ImageActor::New();
 167
 168   actor.SetBlendMode( BlendingMode::OFF );
 169   DALI_TEST_CHECK( BlendingMode::OFF == actor.GetBlendMode() );
 170
 171   actor.SetBlendMode( BlendingMode::AUTO );
 172   DALI_TEST_CHECK( BlendingMode::AUTO == actor.GetBlendMode() );
 173
 174   actor.SetBlendMode( BlendingMode::ON );
 175   DALI_TEST_CHECK( BlendingMode::ON == actor.GetBlendMode() );
 176   END_TEST;
 177 }
 178
 179 int UtcDaliRenderableActorSetCullFace(void)
 180 {
 181   TestApplication application;
 182
 183   tet_infoline("Testing Dali::RenderableActor::SetCullFace()");
 184
 185   BufferImage img = BufferImage::New( 1,1 );
 186   ImageActor actor = ImageActor::New( img );
 187   ImageActor actor2 = ImageActor::New( img );
 188
 189   actor.SetSize(100.0f, 100.0f);
 190   actor.SetParentOrigin(ParentOrigin::CENTER);
 191   actor.SetAnchorPoint(AnchorPoint::CENTER);
 192
 193   actor2.SetSize(100.0f, 100.0f);
 194   actor2.SetParentOrigin(ParentOrigin::CENTER);
 195   actor2.SetAnchorPoint(AnchorPoint::CENTER);
 196
 197   Stage::GetCurrent().Add(actor);
 198   Stage::GetCurrent().Add(actor2);
 199
 200   //Verify whether the correct GL calls are made when actor is face culled in front and back, and
 201   // face culling is disabled for actor2
 202   TraceCallStack& cullFaceTrace = application.GetGlAbstraction().GetCullFaceTrace();
 203   cullFaceTrace.Enable(true);
 204   actor.SetCullFace( CullFrontAndBack );
 205
 206   // flush the queue and render once
 207   application.SendNotification();
 208   application.Render();
 209
 210   cullFaceTrace.Enable(false);
 211   std::stringstream out;
 212
 213   //Verify actor gl state
 214   out.str("");
 215   out << GL_BLEND;
 216   DALI_TEST_EQUALS( cullFaceTrace.TestMethodAndParams(0, "Enable", out.str()), true, TEST_LOCATION);
 217
 218   out.str("");
 219   out << GL_CULL_FACE;
 220   DALI_TEST_EQUALS( cullFaceTrace.TestMethodAndParams(1, "Enable", out.str()), true, TEST_LOCATION);
 221
 222   out.str("");
 223   out << GL_FRONT_AND_BACK;
 224   DALI_TEST_EQUALS( cullFaceTrace.TestMethodAndParams(2, "CullFace", out.str()), true, TEST_LOCATION);
 225
 226   //Verify actor2 gl state
 227   out.str("");
 228   out << GL_CULL_FACE;
 229   DALI_TEST_EQUALS( cullFaceTrace.TestMethodAndParams(3, "Disable", out.str()), true, TEST_LOCATION);
 230
 231   //Verify state through the actor api
 232   DALI_TEST_CHECK( CullFrontAndBack == actor.GetCullFace() );
 233   DALI_TEST_CHECK( CullNone == actor2.GetCullFace() );
 234
 235   /**************************************************************/
 236
 237   //Verify whether the correct GL calls are made when actor2 is face culled in the front
 238   cullFaceTrace.Reset();
 239   cullFaceTrace.Enable(true);
 240   actor2.SetCullFace( CullFront );
 241
 242   // flush the queue and render once
 243   application.SendNotification();
 244   application.Render();
 245
 246   cullFaceTrace.Enable(false);
 247
 248   //Verify actor gl state
 249   out.str("");
 250   out << GL_CULL_FACE;
 251   DALI_TEST_EQUALS( cullFaceTrace.TestMethodAndParams(0, "Enable", out.str()), true, TEST_LOCATION);
 252
 253   out.str("");
 254   out << GL_FRONT_AND_BACK;
 255   DALI_TEST_EQUALS( cullFaceTrace.TestMethodAndParams(1, "CullFace", out.str()), true, TEST_LOCATION);
 256
 257   //Verify actor2 gl state
 258   out.str("");
 259   out << GL_CULL_FACE;
 260   DALI_TEST_EQUALS( cullFaceTrace.TestMethodAndParams(2, "Enable", out.str()), true, TEST_LOCATION);
 261
 262   out.str("");
 263   out << GL_FRONT;
 264   DALI_TEST_EQUALS( cullFaceTrace.TestMethodAndParams(3, "CullFace", out.str()), true, TEST_LOCATION);
 265
 266   //Verify state through the actor api
 267   DALI_TEST_CHECK( CullFrontAndBack == actor.GetCullFace() );
 268   DALI_TEST_CHECK( CullFront == actor2.GetCullFace() );
 269
 270   /**************************************************************/
 271   //Verify whether the correct GL calls are made when face culling is disabled for both actors
 272   cullFaceTrace.Reset();
 273   cullFaceTrace.Enable(true);
 274   actor.SetCullFace( CullNone );
 275   actor2.SetCullFace( CullNone );
 276
 277   // flush the queue and render once
 278   application.SendNotification();
 279   application.Render();
 280
 281   cullFaceTrace.Enable(false);
 282
 283   out.str("");
 284   out << GL_CULL_FACE;
 285   DALI_TEST_EQUALS( cullFaceTrace.TestMethodAndParams(0, "Disable", out.str()), true, TEST_LOCATION);
 286
 287   //Verify state through the actor api
 288   DALI_TEST_CHECK( CullNone == actor.GetCullFace() );
 289   DALI_TEST_CHECK( CullNone == actor2.GetCullFace() );
 290
 291   Stage::GetCurrent().Remove(actor);
 292   Stage::GetCurrent().Remove(actor2);
 293   END_TEST;
 294 }
 295
 296 int UtcDaliRenderableActorGetCullFace(void)
 297 {
 298   TestApplication application;
 299
 300   tet_infoline("Testing Dali::RenderableActor::GetCullFace()");
 301
 302   ImageActor imageActor = ImageActor::New();
 303
 304   DALI_TEST_CHECK( CullNone == imageActor.GetCullFace() );
 305
 306   MeshActor meshActor = MeshActor::New();
 307
 308   DALI_TEST_CHECK( CullBack == meshActor.GetCullFace() );
 309   END_TEST;
 310 }
 311
 312 int UtcDaliRenderableActorSetGetBlendFunc(void)
 313 {
 314   TestApplication application;
 315   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
 316
 317   tet_infoline("Testing Dali::RenderableActor::UtcDaliRenderableActorSetGetBlendFunc()");
 318
 319   BufferImage img = BufferImage::New( 1,1 );
 320   ImageActor actor = ImageActor::New( img );
 321   Stage::GetCurrent().Add( actor );
 322   application.SendNotification();
 323   application.Render();
 324
 325   // Test the defaults as documented int blending.h
 326   {
 327     BlendingFactor::Type srcFactorRgb( BlendingFactor::ZERO );
 328     BlendingFactor::Type destFactorRgb( BlendingFactor::ZERO );
 329     BlendingFactor::Type srcFactorAlpha( BlendingFactor::ZERO );
 330     BlendingFactor::Type destFactorAlpha( BlendingFactor::ZERO );
 331     actor.GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha );
 332     DALI_TEST_EQUALS( BlendingFactor::SRC_ALPHA,           srcFactorRgb,    TEST_LOCATION );
 333     DALI_TEST_EQUALS( BlendingFactor::ONE_MINUS_SRC_ALPHA, destFactorRgb,   TEST_LOCATION );
 334     DALI_TEST_EQUALS( BlendingFactor::ONE,                 srcFactorAlpha,  TEST_LOCATION );
 335     DALI_TEST_EQUALS( BlendingFactor::ONE_MINUS_SRC_ALPHA, destFactorAlpha, TEST_LOCATION );
 336   }
 337
 338   // Set to non-default values
 339   actor.SetBlendFunc( BlendingFactor::ONE_MINUS_SRC_COLOR, BlendingFactor::SRC_ALPHA_SATURATE, BlendingFactor::ONE_MINUS_SRC_COLOR, BlendingFactor::SRC_ALPHA_SATURATE );
 340
 341   // Test that Set was successful
 342   {
 343     BlendingFactor::Type srcFactorRgb( BlendingFactor::ZERO );
 344     BlendingFactor::Type destFactorRgb( BlendingFactor::ZERO );
 345     BlendingFactor::Type srcFactorAlpha( BlendingFactor::ZERO );
 346     BlendingFactor::Type destFactorAlpha( BlendingFactor::ZERO );
 347     actor.GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha );
 348     DALI_TEST_EQUALS( BlendingFactor::ONE_MINUS_SRC_COLOR, srcFactorRgb,    TEST_LOCATION );
 349     DALI_TEST_EQUALS( BlendingFactor::SRC_ALPHA_SATURATE,  destFactorRgb,   TEST_LOCATION );
 350     DALI_TEST_EQUALS( BlendingFactor::ONE_MINUS_SRC_COLOR, srcFactorAlpha,  TEST_LOCATION );
 351     DALI_TEST_EQUALS( BlendingFactor::SRC_ALPHA_SATURATE,  destFactorAlpha, TEST_LOCATION );
 352   }
 353
 354   // Render & check GL commands
 355   application.SendNotification();
 356   application.Render();
 357   DALI_TEST_EQUALS( (GLenum)GL_ONE_MINUS_SRC_COLOR, glAbstraction.GetLastBlendFuncSrcRgb(),   TEST_LOCATION );
 358   DALI_TEST_EQUALS( (GLenum)GL_SRC_ALPHA_SATURATE,  glAbstraction.GetLastBlendFuncDstRgb(),   TEST_LOCATION );
 359   DALI_TEST_EQUALS( (GLenum)GL_ONE_MINUS_SRC_COLOR, glAbstraction.GetLastBlendFuncSrcAlpha(), TEST_LOCATION );
 360   DALI_TEST_EQUALS( (GLenum)GL_SRC_ALPHA_SATURATE,  glAbstraction.GetLastBlendFuncDstAlpha(), TEST_LOCATION );
 361
 362   // Set using separate alpha settings
 363   actor.SetBlendFunc( BlendingFactor::CONSTANT_COLOR, BlendingFactor::ONE_MINUS_CONSTANT_COLOR,
 364                       BlendingFactor::CONSTANT_ALPHA, BlendingFactor::ONE_MINUS_CONSTANT_ALPHA );
 365
 366   // Test that Set was successful
 367   {
 368     BlendingFactor::Type srcFactorRgb( BlendingFactor::ZERO );
 369     BlendingFactor::Type destFactorRgb( BlendingFactor::ZERO );
 370     BlendingFactor::Type srcFactorAlpha( BlendingFactor::ZERO );
 371     BlendingFactor::Type destFactorAlpha( BlendingFactor::ZERO );
 372     actor.GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha );
 373     DALI_TEST_EQUALS( BlendingFactor::CONSTANT_COLOR,            srcFactorRgb,    TEST_LOCATION );
 374     DALI_TEST_EQUALS( BlendingFactor::ONE_MINUS_CONSTANT_COLOR,  destFactorRgb,   TEST_LOCATION );
 375     DALI_TEST_EQUALS( BlendingFactor::CONSTANT_ALPHA,            srcFactorAlpha,  TEST_LOCATION );
 376     DALI_TEST_EQUALS( BlendingFactor::ONE_MINUS_CONSTANT_ALPHA,  destFactorAlpha, TEST_LOCATION );
 377   }
 378
 379   // Render & check GL commands
 380   application.SendNotification();
 381   application.Render();
 382   DALI_TEST_EQUALS( (GLenum)GL_CONSTANT_COLOR,           glAbstraction.GetLastBlendFuncSrcRgb(),   TEST_LOCATION );
 383   DALI_TEST_EQUALS( (GLenum)GL_ONE_MINUS_CONSTANT_COLOR, glAbstraction.GetLastBlendFuncDstRgb(),   TEST_LOCATION );
 384   DALI_TEST_EQUALS( (GLenum)GL_CONSTANT_ALPHA,           glAbstraction.GetLastBlendFuncSrcAlpha(), TEST_LOCATION );
 385   DALI_TEST_EQUALS( (GLenum)GL_ONE_MINUS_CONSTANT_ALPHA, glAbstraction.GetLastBlendFuncDstAlpha(), TEST_LOCATION );
 386   END_TEST;
 387 }
 388
 389 int UtcDaliRenderableActorSetGetAlpha(void)
 390 {
 391   TestApplication application;
 392
 393   tet_infoline("Testing Dali::RenderableActor::SetGetAlpha()");
 394
 395   BufferImage img = BufferImage::New( 1,1 );
 396   ImageActor actor = ImageActor::New( img );
 397   Stage::GetCurrent().Add( actor );
 398   application.SendNotification();
 399   application.Render();
 400
 401   // use the image alpha on actor
 402   actor.SetBlendMode(BlendingMode::ON);
 403
 404   // Test that Set was successful
 405   DALI_TEST_EQUALS( BlendingMode::ON, actor.GetBlendMode(), TEST_LOCATION );
 406
 407   // Now test that it can be set to false
 408   actor.SetBlendMode(BlendingMode::OFF);
 409   DALI_TEST_EQUALS(BlendingMode::OFF, actor.GetBlendMode(), TEST_LOCATION );
 410   END_TEST;
 411 }
 412
 413 int UtcDaliRenderableActorCreateDestroy(void)
 414 {
 415   tet_infoline("Testing Dali::RenderableActor::CreateDestroy()");
 416   RenderableActor* ractor = new RenderableActor;
 417   RenderableActor ractor2( *ractor );
 418   DALI_TEST_CHECK( ractor );
 419   delete ractor;
 420   END_TEST;
 421 }
 422
 423 int UtcDaliRenderableActorSetGetFilterModes(void)
 424 {
 425   TestApplication application;
 426
 427   tet_infoline("Testing Dali::RenderableActor::SetFilterMode() / Dali::RenderableActor::GetFilterMode()");
 428
 429   ImageActor actor = ImageActor::New();
 430
 431   FilterMode::Type minifyFilter = FilterMode::NEAREST;
 432   FilterMode::Type magnifyFilter = FilterMode::NEAREST;
 433
 434   // Default test
 435   actor.GetFilterMode( minifyFilter, magnifyFilter );
 436   DALI_TEST_CHECK( FilterMode::DEFAULT == minifyFilter );
 437   DALI_TEST_CHECK( FilterMode::DEFAULT == magnifyFilter );
 438
 439   // Default/Default
 440   actor.SetFilterMode( FilterMode::DEFAULT, FilterMode::DEFAULT );
 441   actor.GetFilterMode( minifyFilter, magnifyFilter );
 442   DALI_TEST_CHECK( FilterMode::DEFAULT == minifyFilter );
 443   DALI_TEST_CHECK( FilterMode::DEFAULT == magnifyFilter );
 444
 445   // Nearest/Nearest
 446   actor.SetFilterMode( FilterMode::NEAREST, FilterMode::NEAREST );
 447   actor.GetFilterMode( minifyFilter, magnifyFilter );
 448   DALI_TEST_CHECK( FilterMode::NEAREST == minifyFilter );
 449   DALI_TEST_CHECK( FilterMode::NEAREST == magnifyFilter );
 450
 451   // Linear/Linear
 452   actor.SetFilterMode( FilterMode::LINEAR, FilterMode::LINEAR );
 453   actor.GetFilterMode( minifyFilter, magnifyFilter );
 454   DALI_TEST_CHECK( FilterMode::LINEAR == minifyFilter );
 455   DALI_TEST_CHECK( FilterMode::LINEAR == magnifyFilter );
 456
 457   // Nearest/Linear
 458   actor.SetFilterMode( FilterMode::NEAREST, FilterMode::LINEAR );
 459   actor.GetFilterMode( minifyFilter, magnifyFilter );
 460   DALI_TEST_CHECK( FilterMode::NEAREST == minifyFilter );
 461   DALI_TEST_CHECK( FilterMode::LINEAR == magnifyFilter );
 462
 463   // Linear/Nearest
 464   actor.SetFilterMode( FilterMode::LINEAR, FilterMode::NEAREST );
 465   actor.GetFilterMode( minifyFilter, magnifyFilter );
 466   DALI_TEST_CHECK( FilterMode::LINEAR == minifyFilter );
 467   DALI_TEST_CHECK( FilterMode::NEAREST == magnifyFilter );
 468
 469   END_TEST;
 470 }
 471
 472 int UtcDaliRenderableActorSetFilterMode(void)
 473 {
 474   TestApplication application;
 475
 476   tet_infoline("Testing Dali::RenderableActor::SetFilterMode()");
 477
 478   BufferImage img = BufferImage::New( 1,1 );
 479   ImageActor actor = ImageActor::New( img );
 480
 481   actor.SetSize(100.0f, 100.0f);
 482   actor.SetParentOrigin(ParentOrigin::CENTER);
 483   actor.SetAnchorPoint(AnchorPoint::CENTER);
 484
 485   Stage::GetCurrent().Add(actor);
 486
 487   /**************************************************************/
 488
 489   // Default/Default
 490   TraceCallStack& texParameterTrace = application.GetGlAbstraction().GetTexParameterTrace();
 491   texParameterTrace.Reset();
 492   texParameterTrace.Enable( true );
 493
 494   actor.SetFilterMode( FilterMode::DEFAULT, FilterMode::DEFAULT );
 495
 496   // Flush the queue and render once
 497   application.SendNotification();
 498   application.Render();
 499
 500   texParameterTrace.Enable( false );
 501
 502   std::stringstream out;
 503
 504   // Verify actor gl state
 505
 506   // There are two calls to TexParameteri when the texture is first created
 507   // Texture mag filter is not called as the first time set it uses the system default
 508   DALI_TEST_EQUALS( texParameterTrace.CountMethod( "TexParameteri" ), 3, TEST_LOCATION);
 509
 510   out.str("");
 511   out << GL_TEXTURE_2D << ", " << GL_TEXTURE_MIN_FILTER << ", " << GL_LINEAR;
 512   DALI_TEST_EQUALS( texParameterTrace.TestMethodAndParams(2, "TexParameteri", out.str()), true, TEST_LOCATION);
 513
 514   /**************************************************************/
 515
 516   // Default/Default
 517   texParameterTrace = application.GetGlAbstraction().GetTexParameterTrace();
 518   texParameterTrace.Reset();
 519   texParameterTrace.Enable( true );
 520
 521   actor.SetFilterMode( FilterMode::DEFAULT, FilterMode::DEFAULT );
 522
 523   // Flush the queue and render once
 524   application.SendNotification();
 525   application.Render();
 526
 527   texParameterTrace.Enable( false );
 528
 529   // Verify actor gl state
 530
 531   // Should not make any calls when settings are the same
 532   DALI_TEST_EQUALS( texParameterTrace.CountMethod( "TexParameteri" ), 0, TEST_LOCATION);
 533
 534   /**************************************************************/
 535
 536   // Nearest/Nearest
 537   texParameterTrace.Reset();
 538   texParameterTrace.Enable( true );
 539
 540   actor.SetFilterMode( FilterMode::NEAREST, FilterMode::NEAREST );
 541
 542   // Flush the queue and render once
 543   application.SendNotification();
 544   application.Render();
 545
 546   texParameterTrace.Enable( false );
 547
 548   // Verify actor gl state
 549   DALI_TEST_EQUALS( texParameterTrace.CountMethod( "TexParameteri" ), 2, TEST_LOCATION);
 550
 551   out.str("");
 552   out << GL_TEXTURE_2D << ", " << GL_TEXTURE_MIN_FILTER << ", " << GL_NEAREST;
 553   DALI_TEST_EQUALS( texParameterTrace.TestMethodAndParams(0, "TexParameteri", out.str()), true, TEST_LOCATION);
 554
 555   out.str("");
 556   out << GL_TEXTURE_2D << ", " << GL_TEXTURE_MAG_FILTER << ", " << GL_NEAREST;
 557   DALI_TEST_EQUALS( texParameterTrace.TestMethodAndParams(1, "TexParameteri", out.str()), true, TEST_LOCATION);
 558
 559   /**************************************************************/
 560
 561   // Linear/Linear
 562   texParameterTrace.Reset();
 563   texParameterTrace.Enable( true );
 564
 565   actor.SetFilterMode( FilterMode::LINEAR, FilterMode::LINEAR );
 566
 567   // Flush the queue and render once
 568   application.SendNotification();
 569   application.Render();
 570
 571   texParameterTrace.Enable( false );
 572
 573   // Verify actor gl state
 574   DALI_TEST_EQUALS( texParameterTrace.CountMethod( "TexParameteri" ), 2, TEST_LOCATION);
 575
 576   out.str("");
 577   out << GL_TEXTURE_2D << ", " << GL_TEXTURE_MIN_FILTER << ", " << GL_LINEAR;
 578   DALI_TEST_EQUALS( texParameterTrace.TestMethodAndParams(0, "TexParameteri", out.str()), true, TEST_LOCATION);
 579
 580   out.str("");
 581   out << GL_TEXTURE_2D << ", " << GL_TEXTURE_MAG_FILTER << ", " << GL_LINEAR;
 582   DALI_TEST_EQUALS( texParameterTrace.TestMethodAndParams(1, "TexParameteri", out.str()), true, TEST_LOCATION);
 583
 584
 585   /**************************************************************/
 586
 587   // Nearest/Linear
 588   texParameterTrace.Reset();
 589   texParameterTrace.Enable( true );
 590
 591   actor.SetFilterMode( FilterMode::NEAREST, FilterMode::LINEAR );
 592
 593   // Flush the queue and render once
 594   application.SendNotification();
 595   application.Render();
 596
 597   texParameterTrace.Enable( false );
 598
 599   // Verify actor gl state
 600   DALI_TEST_EQUALS( texParameterTrace.CountMethod( "TexParameteri" ), 1, TEST_LOCATION);
 601
 602   out.str("");
 603   out << GL_TEXTURE_2D << ", " << GL_TEXTURE_MIN_FILTER << ", " << GL_NEAREST;
 604   DALI_TEST_EQUALS( texParameterTrace.TestMethodAndParams(0, "TexParameteri", out.str()), true, TEST_LOCATION);
 605
 606   /**************************************************************/
 607
 608   // Default/Default
 609   texParameterTrace.Reset();
 610   texParameterTrace.Enable( true );
 611
 612   actor.SetFilterMode( FilterMode::DEFAULT, FilterMode::DEFAULT );
 613
 614   // Flush the queue and render once
 615   application.SendNotification();
 616   application.Render();
 617
 618   texParameterTrace.Enable( false );
 619
 620   // Verify actor gl state
 621   DALI_TEST_EQUALS( texParameterTrace.CountMethod( "TexParameteri" ), 1, TEST_LOCATION);
 622
 623   out.str("");
 624   out << GL_TEXTURE_2D << ", " << GL_TEXTURE_MIN_FILTER << ", " << GL_LINEAR;
 625   DALI_TEST_EQUALS( texParameterTrace.TestMethodAndParams(0, "TexParameteri", out.str()), true, TEST_LOCATION);
 626
 627   /**************************************************************/
 628
 629   // None/None
 630   texParameterTrace.Reset();
 631   texParameterTrace.Enable( true );
 632
 633   actor.SetFilterMode( FilterMode::NONE, FilterMode::NONE );
 634
 635   // Flush the queue and render once
 636   application.SendNotification();
 637   application.Render();
 638
 639   texParameterTrace.Enable( false );
 640
 641   // Verify actor gl state
 642   DALI_TEST_EQUALS( texParameterTrace.CountMethod( "TexParameteri" ), 1, TEST_LOCATION);
 643
 644   out.str("");
 645   out << GL_TEXTURE_2D << ", " << GL_TEXTURE_MIN_FILTER << ", " << GL_NEAREST_MIPMAP_LINEAR;
 646   DALI_TEST_EQUALS( texParameterTrace.TestMethodAndParams(0, "TexParameteri", out.str()), true, TEST_LOCATION);
 647
 648   /**************************************************************/
 649
 650   Stage::GetCurrent().Remove(actor);
 651
 652   END_TEST;
 653 }
 654
 655 int UtcDaliRenderableActorSetShaderEffect(void)
 656 {
 657   TestApplication application;
 658   BufferImage img = BufferImage::New( 1,1 );
 659   ImageActor actor = ImageActor::New( img );
 660   Stage::GetCurrent().Add( actor );
 661
 662   // flush the queue and render once
 663   application.SendNotification();
 664   application.Render();
 665   GLuint lastShaderCompiledBefore = application.GetGlAbstraction().GetLastShaderCompiled();
 666
 667   application.GetGlAbstraction().EnableShaderCallTrace( true );
 668
 669   const std::string vertexShader = "UtcDaliRenderableActorSetShaderEffect-VertexSource";
 670   const std::string fragmentShader = "UtcDaliRenderableActorSetShaderEffect-FragmentSource";
 671   ShaderEffect effect = ShaderEffect::New(vertexShader, fragmentShader );
 672   DALI_TEST_CHECK( effect != actor.GetShaderEffect() );
 673
 674   actor.SetShaderEffect( effect );
 675   DALI_TEST_CHECK( effect == actor.GetShaderEffect() );
 676
 677   // flush the queue and render once
 678   application.SendNotification();
 679   application.Render();
 680
 681   GLuint lastShaderCompiledAfter = application.GetGlAbstraction().GetLastShaderCompiled();
 682   DALI_TEST_EQUALS( lastShaderCompiledAfter, lastShaderCompiledBefore + 2, TEST_LOCATION );
 683
 684   std::string actualVertexShader = application.GetGlAbstraction().GetShaderSource( lastShaderCompiledBefore + 1 );
 685   DALI_TEST_EQUALS( vertexShader,
 686                     actualVertexShader.substr( actualVertexShader.length() - vertexShader.length() ), TEST_LOCATION );
 687   std::string actualFragmentShader = application.GetGlAbstraction().GetShaderSource( lastShaderCompiledBefore + 2 );
 688   DALI_TEST_EQUALS( fragmentShader,
 689                     actualFragmentShader.substr( actualFragmentShader.length() - fragmentShader.length() ), TEST_LOCATION );
 690
 691   END_TEST;
 692 }
 693
 694 int UtcDaliRenderableActorGetShaderEffect(void)
 695 {
 696   TestApplication application;
 697   ImageActor actor = ImageActor::New();
 698
 699   ShaderEffect effect = ShaderEffect::New("UtcDaliRenderableActorGetShaderEffect-VertexSource", "UtcDaliRenderableActorGetShaderEffect-FragmentSource" );
 700   actor.SetShaderEffect(effect);
 701
 702   DALI_TEST_CHECK(effect == actor.GetShaderEffect());
 703   END_TEST;
 704 }
 705
 706 int UtcDaliRenderableActorRemoveShaderEffect01(void)
 707 {
 708   TestApplication application;
 709   ImageActor actor = ImageActor::New();
 710
 711   ShaderEffect defaultEffect = actor.GetShaderEffect();
 712
 713   ShaderEffect effect = ShaderEffect::New("UtcDaliRenderableActorRemoveShaderEffect-VertexSource", "UtcDaliRenderableActorRemoveShaderEffect-FragmentSource" );
 714   actor.SetShaderEffect(effect);
 715
 716   DALI_TEST_CHECK(effect == actor.GetShaderEffect());
 717
 718   actor.RemoveShaderEffect();
 719
 720   DALI_TEST_CHECK(defaultEffect == actor.GetShaderEffect());
 721   END_TEST;
 722 }
 723
 724 int UtcDaliRenderableActorRemoveShaderEffect02(void)
 725 {
 726   TestApplication application;
 727   ImageActor actor = ImageActor::New();
 728
 729   ShaderEffect defaultEffect = actor.GetShaderEffect();
 730
 731   actor.RemoveShaderEffect();
 732
 733   DALI_TEST_CHECK(defaultEffect == actor.GetShaderEffect());
 734   END_TEST;
 735 }
 736
 737 int UtcDaliSetShaderEffectRecursively(void)
 738 {
 739   TestApplication application;
 740   /**
 741    * create a tree
 742    *                 actor1
 743    *           actor2       actor4
 744    *       actor3 imageactor1
 745    * imageactor2
 746    */
 747   BufferImage img = BufferImage::New( 1,1 );
 748   ImageActor actor1 = ImageActor::New( img );
 749   Actor actor2 = Actor::New();
 750   actor1.Add( actor2 );
 751   Actor actor3 = Actor::New();
 752   actor2.Add( actor3 );
 753   ImageActor imageactor1 = ImageActor::New( img );
 754   actor2.Add( imageactor1 );
 755   ImageActor imageactor2 = ImageActor::New( img );
 756   actor3.Add( imageactor2 );
 757   Actor actor4 = Actor::New();
 758   actor1.Add( actor4 );
 759   Stage::GetCurrent().Add( actor1 );
 760
 761   // flush the queue and render once
 762   application.SendNotification();
 763   application.Render();
 764   GLuint lastShaderCompiledBefore = application.GetGlAbstraction().GetLastShaderCompiled();
 765
 766   application.GetGlAbstraction().EnableShaderCallTrace( true );
 767
 768   const std::string vertexShader = "UtcDaliRenderableActorSetShaderEffect-VertexSource";
 769   const std::string fragmentShader = "UtcDaliRenderableActorSetShaderEffect-FragmentSource";
 770   // test with empty effect
 771   ShaderEffect effect;
 772   SetShaderEffectRecursively( actor1, effect );
 773
 774   effect = ShaderEffect::New(vertexShader, fragmentShader );
 775
 776   DALI_TEST_CHECK( effect != actor1.GetShaderEffect() );
 777   DALI_TEST_CHECK( effect != imageactor1.GetShaderEffect() );
 778   DALI_TEST_CHECK( effect != imageactor2.GetShaderEffect() );
 779
 780   SetShaderEffectRecursively( actor1, effect );
 781   DALI_TEST_CHECK( effect == imageactor1.GetShaderEffect() );
 782   DALI_TEST_CHECK( effect == imageactor2.GetShaderEffect() );
 783
 784   // flush the queue and render once
 785   application.SendNotification();
 786   application.Render();
 787
 788   GLuint lastShaderCompiledAfter = application.GetGlAbstraction().GetLastShaderCompiled();
 789   DALI_TEST_EQUALS( lastShaderCompiledAfter, lastShaderCompiledBefore + 2, TEST_LOCATION );
 790
 791   std::string actualVertexShader = application.GetGlAbstraction().GetShaderSource( lastShaderCompiledBefore + 1 );
 792   DALI_TEST_EQUALS( vertexShader,
 793                     actualVertexShader.substr( actualVertexShader.length() - vertexShader.length() ), TEST_LOCATION );
 794   std::string actualFragmentShader = application.GetGlAbstraction().GetShaderSource( lastShaderCompiledBefore + 2 );
 795   DALI_TEST_EQUALS( fragmentShader,
 796                     actualFragmentShader.substr( actualFragmentShader.length() - fragmentShader.length() ), TEST_LOCATION );
 797
 798   // remove from one that does not have shader
 799   RemoveShaderEffectRecursively( actor4 );
 800
 801   // remove partially
 802   RemoveShaderEffectRecursively( actor3 );
 803   DALI_TEST_CHECK( effect == imageactor1.GetShaderEffect() );
 804   DALI_TEST_CHECK( effect != imageactor2.GetShaderEffect() );
 805
 806   // test with empty actor just to check it does not crash
 807   Actor empty;
 808   SetShaderEffectRecursively( empty, effect );
 809   RemoveShaderEffectRecursively( empty );
 810
 811   // test with actor with no children just to check it does not crash
 812   Actor loner = Actor::New();
 813   Stage::GetCurrent().Add( loner );
 814   SetShaderEffectRecursively( loner, effect );
 815   RemoveShaderEffectRecursively( loner );
 816
 817   END_TEST;
 818 }
 819
 820 int UtcDaliRenderableActorTestClearCache01(void)
 821 {
 822   // Testing the framebuffer state caching in frame-buffer-state-caching.cpp
 823   TestApplication application;
 824
 825   tet_infoline("Testing Dali::RenderableActor::ClearCache01()");
 826
 827   BufferImage img = BufferImage::New( 1,1 );
 828   ImageActor actor = ImageActor::New( img );
 829
 830   actor.SetParentOrigin(ParentOrigin::CENTER);
 831   actor.SetAnchorPoint(AnchorPoint::CENTER);
 832
 833   Stage::GetCurrent().Add(actor);
 834
 835   /**************************************************************/
 836   // Flush the queue and render once
 837   application.SendNotification();
 838   application.Render();
 839
 840   // There should be a single call to Clear
 841   DALI_TEST_EQUALS( application.GetGlAbstraction().GetClearCountCalled() , 1u, TEST_LOCATION );
 842
 843   // the last set clear mask should be COLOR, DEPTH & STENCIL which occurs at the start of each frame
 844   GLbitfield mask = application.GetGlAbstraction().GetLastClearMask();
 845   DALI_TEST_CHECK( mask & GL_DEPTH_BUFFER_BIT );
 846   DALI_TEST_CHECK( mask & GL_STENCIL_BUFFER_BIT );
 847   DALI_TEST_CHECK( mask & GL_COLOR_BUFFER_BIT );
 848
 849   END_TEST;
 850 }
 851
 852 int UtcDaliRenderableActorTestClearCache02(void)
 853 {
 854   // Testing the framebuffer state caching in frame-buffer-state-caching.cpp
 855   TestApplication application;
 856
 857   tet_infoline("Testing Dali::RenderableActor::ClearCache02()");
 858
 859   // use RGB so alpha is disabled and the actors are drawn opaque
 860   BufferImage img = BufferImage::New( 10,10 ,Pixel::RGB888 );
 861
 862   // Without caching DALi perform clears in the following places
 863   // Root
 864   // | glClear #1 ( everything at start of frame )
 865   // |
 866   // |
 867   // | glClear #2 ( start of layer with opaque actors )
 868   // | ----> Layer1
 869   // |     -> Actor 1 ( opaque )
 870   // |     -> Actor 2 ( opaque )
 871   // |
 872   // |
 873   // | glClear  #3 ( start of layer with opaque actors )
 874   // |----> Layer 2
 875   // |     -> Actor 3 ( opaque )
 876   // |     -> Actor 4 ( opaque )
 877   //
 878   // With caching enabled glClear should only be called twice, at points #1 and #3.
 879   // At #1 with depth, color and stencil cleared
 880   // At #3 with depth cleared
 881   // #2 is not required because the buffer has already been cleared at #1
 882
 883   Layer layer1 = Layer::New();
 884   layer1.Add( ImageActor::New( img ) );
 885   layer1.Add( ImageActor::New( img ) );
 886
 887   Layer layer2 = Layer::New();
 888   layer2.Add( ImageActor::New( img ) );
 889   layer2.Add( ImageActor::New( img ) );
 890
 891   Stage::GetCurrent().Add( layer1 );
 892   Stage::GetCurrent().Add( layer2 );
 893
 894   /**************************************************************/
 895
 896   // Flush the queue and render once
 897   application.SendNotification();
 898   application.Render();
 899
 900   // There should be a 2 calls to Clear
 901   DALI_TEST_EQUALS( application.GetGlAbstraction().GetClearCountCalled() , 2u, TEST_LOCATION );
 902
 903   // the last set clear mask should be  DEPTH & STENCIL & COLOR
 904   GLbitfield mask = application.GetGlAbstraction().GetLastClearMask();
 905
 906   tet_printf(" clear count = %d \n",  application.GetGlAbstraction().GetClearCountCalled() );
 907
 908   // The last clear should just be DEPTH BUFFER, not color and stencil which were cleared at the start of the frame
 909   DALI_TEST_CHECK( mask & GL_DEPTH_BUFFER_BIT );
 910   DALI_TEST_CHECK( ! ( mask & GL_COLOR_BUFFER_BIT ) );
 911   DALI_TEST_CHECK( ! ( mask & GL_STENCIL_BUFFER_BIT ) );
 912
 913   END_TEST;
 914 }
 915
 916 int UtcDaliRenderableActorTestClearCache03(void)
 917 {
 918   // Testing the framebuffer state caching in frame-buffer-state-caching.cpp
 919   TestApplication application;
 920
 921   tet_infoline("Testing Dali::RenderableActor::ClearCache03()");
 922
 923   // use RGB so alpha is disabled and the actors are drawn opaque
 924   BufferImage img = BufferImage::New( 10,10 ,Pixel::RGB888 );
 925
 926   // Without caching DALi perform clears in the following places
 927   // Root
 928   // | 1-## glClear ( COLOR, DEPTH, STENCIL )
 929   // |
 930   // | ----> Layer1
 931   // |     2-##  glClear  ( STENCIL )
 932   // |     -> Actor 1 ( stencil )
 933   // |     3-##  glClear  ( DEPTH )
 934   // |     -> Actor 2 ( opaque )  // need 2 opaque actors to bypass optimisation of turning off depth test
 935   // |     -> Actor 3 ( opaque )
 936   // |
 937   // |
 938   // |----> Layer 2
 939   // |     4-##  glClear  ( STENCIL )
 940   // |     -> Actor 4 ( stencil )
 941   // |     5-##  glClear  ( DEPTH )
 942   // |     -> Actor 5 ( opaque )  // need 2 opaque actors to bypass optimisation of turning off depth test
 943   // |     -> Actor 6 ( opaque )
 944   //
 945   // With caching enabled glClear will not be called at ## 2 and ## 3 ( because those buffers are already clear).
 946   //
 947   // @TODO Add further optimisation to look-ahead in the render-list to see if
 948   // When performing STENCIL clear, check if there another layer after it.
 949   // If there is, combine the STENCIL with a DEPTH clear.
 950   //
 951
 952   Layer layer1 = Layer::New();
 953   ImageActor actor1 =  ImageActor::New( img );
 954   ImageActor actor2 =  ImageActor::New( img );
 955   ImageActor actor3 =  ImageActor::New( img );
 956
 957   actor2.SetDrawMode( DrawMode::STENCIL );
 958
 959   layer1.Add( actor1 );
 960   layer1.Add( actor2 );
 961   layer1.Add( actor3 );
 962
 963   Layer layer2 = Layer::New();
 964   ImageActor actor4 =  ImageActor::New( img );
 965   ImageActor actor5 =  ImageActor::New( img );
 966   ImageActor actor6 =  ImageActor::New( img );
 967
 968   actor4.SetDrawMode( DrawMode::STENCIL );
 969
 970   layer2.Add( actor4 );
 971   layer2.Add( actor5 );
 972   layer2.Add( actor6 );
 973
 974   Stage::GetCurrent().Add( layer1 );
 975   Stage::GetCurrent().Add( layer2 );
 976
 977
 978   /**************************************************************/
 979
 980   // Flush the queue and render once
 981   application.SendNotification();
 982   application.Render();
 983
 984   // There should be a 3 calls to Clear ( one for everything, one for stencil, one for depth buffer).
 985   DALI_TEST_EQUALS( application.GetGlAbstraction().GetClearCountCalled() , 3u, TEST_LOCATION );
 986
 987   // the last set clear mask should be  DEPTH & STENCIL & COLOR
 988   GLbitfield mask = application.GetGlAbstraction().GetLastClearMask();
 989
 990   tet_printf(" clear count = %d \n",  application.GetGlAbstraction().GetClearCountCalled() );
 991   tet_printf(" clear mask  = %x \n",  mask);
 992
 993   // The last clear should just be DEPTH BUFFER and stencil
 994   DALI_TEST_CHECK(  !( mask & GL_COLOR_BUFFER_BIT ) );
 995   DALI_TEST_CHECK(  !( mask & GL_STENCIL_BUFFER_BIT ) );
 996   DALI_TEST_CHECK(  mask & GL_DEPTH_BUFFER_BIT );
 997
 998
 999   END_TEST;
1000 }