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