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