automated-tests/src/dali/utc-Dali-ShaderEffect.cpp

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include <iostream>
  19
  20 #include <stdlib.h>
  21 #include <dali/public-api/dali-core.h>
  22 #include <dali-test-suite-utils.h>
  23
  24 using namespace Dali;
  25
  26 void utc_dali_shader_effect_startup(void)
  27 {
  28   test_return_value = TET_UNDEF;
  29 }
  30
  31 void utc_dali_shader_effect_cleanup(void)
  32 {
  33   test_return_value = TET_PASS;
  34 }
  35
  36 namespace
  37 {
  38
  39 static const char* VertexSource =
  40 "This is a custom vertex shader\n"
  41 "made on purpose to look nothing like a normal vertex shader inside dali\n";
  42
  43 static const char* FragmentSource =
  44 "This is a custom fragment shader\n"
  45 "made on purpose to look nothing like a normal fragment shader inside dali\n";
  46
  47 static const char* FragmentSourceUsingExtensions =
  48 "This is a custom fragment shader using extensions\n"
  49 "made on purpose to look nothing like a normal fragment shader inside dali\n";
  50
  51 const int GETSOURCE_BUFFER_SIZE = 0x10000;
  52
  53
  54 struct TestConstraintToVector3
  55 {
  56   TestConstraintToVector3(Vector3 target)
  57   : mTarget(target)
  58   {
  59   }
  60
  61   Vector3 operator()(const Vector3& current)
  62   {
  63     return mTarget;
  64   }
  65
  66   Vector3 mTarget;
  67 };
  68
  69 struct TestConstraintFromPositionToVector3
  70 {
  71   TestConstraintFromPositionToVector3()
  72   {
  73   }
  74
  75   Vector3 operator()(const Vector3& current, const PropertyInput& position)
  76   {
  77
  78     return position.GetVector3();
  79   }
  80 };
  81
  82 struct TestConstraintToVector3Double
  83 {
  84   TestConstraintToVector3Double(Vector3 target)
  85   : mTarget(target)
  86   {
  87   }
  88
  89   Vector3 operator()(const Vector3& current)
  90   {
  91     return mTarget * 2.0f;
  92   }
  93
  94   Vector3 mTarget;
  95 };
  96
  97 class ShaderEffectExtension : public ShaderEffect::Extension {};
  98
  99
 100 class TestExtension : public ShaderEffect::Extension
 101 {
 102 public:
 103   TestExtension( bool& deleted )
 104   : mDeleted(deleted)
 105   {
 106     mDeleted = false;
 107   }
 108   ~TestExtension()
 109   {
 110     mDeleted = true;
 111   }
 112   bool IsAlive() const
 113   {
 114     return !mDeleted;
 115   }
 116 private:
 117   bool& mDeleted;
 118 };
 119
 120 } // anon namespace
 121
 122
 123 int UtcDaliShaderEffectMethodNew01(void)
 124 {
 125   TestApplication application;
 126
 127   ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 128   DALI_TEST_CHECK(effect);
 129   END_TEST;
 130 }
 131
 132 int UtcDaliShaderEffectMethodNew02(void)
 133 {
 134   TestApplication application;
 135
 136   ShaderEffect effect;
 137
 138   try
 139   {
 140     // New must be called to create a ShaderEffect or it wont be valid.
 141     effect.SetUniform( "uUniform", 0 );
 142     DALI_TEST_CHECK( false );
 143   }
 144   catch (Dali::DaliException& e)
 145   {
 146     // Tests that a negative test of an assertion succeeds
 147     tet_printf("Assertion %s failed at %s\n", e.mCondition.c_str(), e.mLocation.c_str());
 148     DALI_TEST_CHECK( !effect );
 149   }
 150   END_TEST;
 151 }
 152
 153 int UtcDaliShaderEffectMethodNew03(void)
 154 {
 155   TestApplication application;
 156
 157   ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource, VertexSource, FragmentSource, ShaderEffect::HINT_NONE );
 158   DALI_TEST_CHECK(effect);
 159   END_TEST;
 160 }
 161
 162 int UtcDaliShaderEffectMethodNew04(void)
 163 {
 164   TestApplication application;
 165   tet_infoline("Testing prefixed version of Dali::ShaderEffect::New()");
 166
 167   std::string fragmentShaderPrefix = "#define TEST_FS 1\n#extension GL_OES_standard_derivatives : enable";
 168   std::string vertexShaderPrefix = "#define TEST_VS 1";
 169
 170   try
 171   {
 172     // Call render to compile default shaders.
 173     application.SendNotification();
 174     application.Render();
 175     application.Render();
 176     application.Render();
 177
 178     GLuint lastShaderCompiledBefore = application.GetGlAbstraction().GetLastShaderCompiled();
 179     ShaderEffect effect = ShaderEffect::NewWithPrefix( vertexShaderPrefix, VertexSource,
 180                                                        fragmentShaderPrefix, FragmentSourceUsingExtensions,
 181                                                        GEOMETRY_TYPE_IMAGE, ShaderEffect::HINT_NONE );
 182
 183     BitmapImage image = CreateBitmapImage();
 184     ImageActor actor = ImageActor::New( image );
 185     actor.SetSize( 100.0f, 100.0f );
 186     actor.SetName("TestImageFilenameActor");
 187     actor.SetShaderEffect(effect);
 188     Stage::GetCurrent().Add(actor);
 189
 190     application.SendNotification();
 191     application.Render();
 192     GLuint lastShaderCompiledAfter = application.GetGlAbstraction().GetLastShaderCompiled();
 193     bool testResult = false;
 194
 195     // we should have compiled 2 shaders.
 196     DALI_TEST_EQUALS( lastShaderCompiledAfter, lastShaderCompiledBefore + 2, TEST_LOCATION );
 197
 198     char testVertexSourceResult[GETSOURCE_BUFFER_SIZE];
 199     char testFragmentSourceResult[GETSOURCE_BUFFER_SIZE];
 200
 201      // we are interested in the first two.
 202     GLuint vertexShaderId = lastShaderCompiledBefore + 1;
 203     GLuint fragmentShaderId = lastShaderCompiledBefore + 2;
 204
 205     GLsizei lengthVertexResult;
 206     GLsizei lengthFragmentResult;
 207
 208     application.GetGlAbstraction().GetShaderSource(vertexShaderId, GETSOURCE_BUFFER_SIZE, &lengthVertexResult, testVertexSourceResult);
 209     application.GetGlAbstraction().GetShaderSource(fragmentShaderId, GETSOURCE_BUFFER_SIZE, &lengthFragmentResult, testFragmentSourceResult);
 210
 211     int vertexShaderHasPrefix = strncmp(testVertexSourceResult, "#define ", strlen("#define "));
 212     int fragmentShaderHasPrefix = strncmp(testFragmentSourceResult, "#define ", strlen("#define "));
 213     testResult = (vertexShaderHasPrefix == 0) && (fragmentShaderHasPrefix == 0);
 214
 215     DALI_TEST_CHECK(testResult);
 216   }
 217   catch(Dali::DaliException& e)
 218   {
 219     tet_printf("Assertion %s failed at %s\n", e.mCondition.c_str(), e.mLocation.c_str());
 220     tet_result( TET_FAIL );
 221   }
 222   END_TEST;
 223 }
 224
 225 int UtcDaliShaderEffectMethodNew05(void)
 226 {
 227   TestApplication application;
 228
 229   // heap constructor / destructor
 230   DefaultFunctionCoverage<ShaderEffect> shaderEffect;
 231   DefaultFunctionCoverage<ShaderEffectExtension> shaderEffectExtension;
 232
 233   END_TEST;
 234 }
 235
 236 int UtcDaliShaderEffectMethodNew06(void)
 237 {
 238   TestApplication application;
 239   tet_infoline("Testing Dali::ShaderEffect::New() with shader sources for different geometry types");
 240
 241   ShaderEffect effect = ShaderEffect::New( "imageVertexShader", "imageFragmentShader",
 242                                            "textVertexShader", "textFragmentShader",
 243                                            "texturedMeshVertexShader", "texturedMeshFragmentShader",
 244                                            "meshVertexShader", "meshFragmentShader",
 245                                            ShaderEffect::HINT_NONE );
 246   DALI_TEST_CHECK(effect);
 247   END_TEST;
 248 }
 249
 250
 251 int UtcDaliShaderEffectMethodDownCast(void)
 252 {
 253   TestApplication application;
 254   tet_infoline("Testing Dali::ShaderEffect::DownCast()");
 255
 256   ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 257
 258   BaseHandle object(effect);
 259
 260   ShaderEffect effect2 = ShaderEffect::DownCast(object);
 261   DALI_TEST_CHECK(effect2);
 262
 263   ShaderEffect effect3 = DownCast< ShaderEffect >(object);
 264   DALI_TEST_CHECK(effect3);
 265
 266   BaseHandle unInitializedObject;
 267   ShaderEffect effect4 = ShaderEffect::DownCast(unInitializedObject);
 268   DALI_TEST_CHECK(!effect4);
 269
 270   ShaderEffect effect5 = DownCast< ShaderEffect >(unInitializedObject);
 271   DALI_TEST_CHECK(!effect5);
 272   END_TEST;
 273 }
 274
 275 int UtcDaliShaderEffectMethodDelete01(void)
 276 {
 277    TestApplication application;
 278
 279    // get the default shaders built, this is not required but makes it
 280    // easier to debug the TET case and isolate the custom shader compilation.
 281    application.SendNotification();
 282    application.Render();
 283
 284    GLuint beforeShaderCompiled = application.GetGlAbstraction().GetLastShaderCompiled();
 285
 286    // create a new shader effect
 287    // the vertex and fragment shader will be cached in the ShaderFactory
 288    ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 289
 290    // destroy the shader effect
 291    effect.Reset();
 292
 293    // Create the same shader effect again, this should now use the cached version
 294    // held in the shader factory
 295    effect= ShaderEffect::New( VertexSource, FragmentSource );
 296
 297    // Compile the shader effect
 298    application.SendNotification();
 299    application.Render();
 300
 301    GLuint lastShaderCompiled = application.GetGlAbstraction().GetLastShaderCompiled();
 302    // no shaders were compiled as they are now compiled on demand and this shader was not used
 303    DALI_TEST_EQUALS( beforeShaderCompiled, lastShaderCompiled, TEST_LOCATION );
 304
 305    END_TEST;
 306 }
 307
 308 int UtcDaliShaderEffectMethodSetUniformFloat(void)
 309 {
 310   TestApplication application;
 311
 312   ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 313   DALI_TEST_CHECK( effect );
 314
 315   BitmapImage image = CreateBitmapImage();
 316
 317   effect.SetUniform( "uFloat", 1.0f );
 318
 319   ImageActor actor = ImageActor::New( image );
 320   actor.SetSize( 100.0f, 100.0f );
 321   actor.SetName("TestImageFilenameActor");
 322   actor.SetShaderEffect(effect);
 323   Stage::GetCurrent().Add(actor);
 324
 325   application.SendNotification();
 326   application.Render();
 327
 328   DALI_TEST_CHECK(
 329       application.GetGlAbstraction().CheckUniformValue(
 330           "uFloat", 1.0f ) );
 331   END_TEST;
 332 }
 333
 334 int UtcDaliShaderEffectMethodSetUniformVector2(void)
 335 {
 336   TestApplication application;
 337
 338   ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 339   DALI_TEST_CHECK( effect );
 340
 341   BitmapImage image = CreateBitmapImage();
 342
 343   effect.SetUniform( "uVec2", Vector2( 2.0f, 3.0f ) );
 344
 345   ImageActor actor = ImageActor::New( image );
 346   actor.SetSize( 100.0f, 100.0f );
 347   actor.SetName("TestImageFilenameActor");
 348   actor.SetShaderEffect(effect);
 349   Stage::GetCurrent().Add(actor);
 350
 351   application.SendNotification();
 352   application.Render();
 353
 354   DALI_TEST_CHECK(
 355       application.GetGlAbstraction().CheckUniformValue(
 356           "uVec2", Vector2( 2.0f, 3.0f ) ) );
 357   END_TEST;
 358 }
 359
 360 int UtcDaliShaderEffectMethodSetUniformVector3(void)
 361 {
 362   TestApplication application;
 363
 364   ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 365   DALI_TEST_CHECK( effect );
 366
 367   BitmapImage image = CreateBitmapImage();
 368
 369   effect.SetUniform( "uVec3", Vector3( 4.0f, 5.0f, 6.0f ) );
 370
 371   ImageActor actor = ImageActor::New( image );
 372   actor.SetSize( 100.0f, 100.0f );
 373   actor.SetName("TestImageFilenameActor");
 374   actor.SetShaderEffect(effect);
 375   Stage::GetCurrent().Add(actor);
 376
 377   application.SendNotification();
 378   application.Render();
 379
 380   DALI_TEST_CHECK(
 381       application.GetGlAbstraction().CheckUniformValue(
 382           "uVec3", Vector3( 4.0f, 5.0f, 6.0f ) ) );
 383   END_TEST;
 384 }
 385
 386 int UtcDaliShaderEffectMethodSetUniformVector4(void)
 387 {
 388   TestApplication application;
 389
 390   ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 391   DALI_TEST_CHECK( effect );
 392
 393   BitmapImage image = CreateBitmapImage();
 394
 395   effect.SetUniform( "uVec4", Vector4( 7.0f, 8.0f, 9.0f, 10.0f ) );
 396
 397   ImageActor actor = ImageActor::New( image );
 398   actor.SetSize( 100.0f, 100.0f );
 399   actor.SetName("TestImageFilenameActor");
 400   actor.SetShaderEffect(effect);
 401   Stage::GetCurrent().Add(actor);
 402
 403   application.SendNotification();
 404   application.Render();
 405
 406   DALI_TEST_CHECK(
 407       application.GetGlAbstraction().CheckUniformValue(
 408           "uVec4", Vector4( 7.0f, 8.0f, 9.0f, 10.0f ) ) );
 409   END_TEST;
 410 }
 411
 412 int UtcDaliShaderEffectMethodSetUniformMatrix(void)
 413 {
 414   TestApplication application;
 415
 416   ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 417   DALI_TEST_CHECK( effect );
 418
 419   BitmapImage image = CreateBitmapImage();
 420
 421   effect.SetUniform( "uModelView", Matrix::IDENTITY );
 422
 423   ImageActor actor = ImageActor::New( image );
 424   actor.SetSize( 100.0f, 100.0f );
 425   actor.SetName("TestImageFilenameActor");
 426   actor.SetShaderEffect(effect);
 427   Stage::GetCurrent().Add(actor);
 428
 429   application.SendNotification();
 430   application.Render();
 431
 432   DALI_TEST_CHECK(
 433       application.GetGlAbstraction().CheckUniformValue(
 434           "uModelView", Matrix::IDENTITY ) );
 435   END_TEST;
 436 }
 437
 438 int UtcDaliShaderEffectMethodSetUniformMatrix3(void)
 439 {
 440   TestApplication application;
 441
 442   ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 443   DALI_TEST_CHECK( effect );
 444
 445   BitmapImage image = CreateBitmapImage();
 446
 447   Matrix3 matIdentity(1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f);
 448   effect.SetUniform( "uMatrix3", matIdentity );
 449
 450   ImageActor actor = ImageActor::New( image );
 451   actor.SetSize( 100.0f, 100.0f );
 452   actor.SetName("TestImageFilenameActor");
 453   actor.SetShaderEffect(effect);
 454   Stage::GetCurrent().Add(actor);
 455
 456   application.SendNotification();
 457   application.Render();
 458
 459   DALI_TEST_CHECK( application.GetGlAbstraction().CheckUniformValue("uMatrix3", matIdentity) );
 460   END_TEST;
 461 }
 462
 463 int UtcDaliShaderEffectMethodSetUniformViewport(void)
 464 {
 465   TestApplication application;
 466
 467   ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 468   DALI_TEST_CHECK( effect );
 469
 470   BitmapImage image = CreateBitmapImage();
 471
 472   ImageActor actor = ImageActor::New( image );
 473   actor.SetSize( 100.0f, 100.0f );
 474   actor.SetName("TestImageFilenameActor");
 475   actor.SetShaderEffect(effect);
 476   Stage::GetCurrent().Add(actor);
 477
 478   effect.SetUniform( "uVec2", Vector2( 0.0f, 0.0f ), ShaderEffect::COORDINATE_TYPE_VIEWPORT_POSITION );
 479   effect.SetUniform( "uVec2Dir", Vector2( 1.0f, 2.0f ), ShaderEffect::COORDINATE_TYPE_VIEWPORT_DIRECTION );
 480
 481   application.SendNotification();
 482   application.Render();
 483
 484   const Vector2& stageSize(Stage::GetCurrent().GetSize());
 485
 486   DALI_TEST_CHECK(
 487       application.GetGlAbstraction().CheckUniformValue(
 488           "uVec2", Vector2( stageSize.x/2, -stageSize.y/2 ) ) );
 489
 490   DALI_TEST_CHECK(
 491       application.GetGlAbstraction().CheckUniformValue(
 492           "uVec2Dir", Vector2( -1.0f, 2.0f ) ) );
 493   END_TEST;
 494 }
 495
 496 int UtcDaliShaderEffectMethodSetEffectImage(void)
 497 {
 498   TestApplication application;
 499
 500   ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 501   DALI_TEST_CHECK( effect );
 502
 503   BitmapImage image = CreateBitmapImage();
 504
 505   effect.SetEffectImage(image);
 506
 507   ImageActor actor = ImageActor::New( image );
 508   actor.SetSize( 100.0f, 100.0f );
 509   actor.SetName("TestImageFilenameActor");
 510   actor.SetShaderEffect(effect);
 511   Stage::GetCurrent().Add(actor);
 512
 513   application.SendNotification();
 514   application.Render(16);
 515   application.SendNotification();
 516   application.Render(16);
 517   application.SendNotification();
 518
 519   DALI_TEST_CHECK( application.GetGlAbstraction().CheckUniformValue( "sEffect", 1 ) );
 520   END_TEST;
 521 }
 522
 523 int UtcDaliShaderEffectMethodSetEffectImageAndDelete(void)
 524 {
 525   TestApplication application;
 526
 527   ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 528
 529   BitmapImage effectImage = CreateBitmapImage();
 530   effect.SetEffectImage(effectImage);
 531
 532   ImageActor actor = ImageActor::New();
 533
 534   actor.SetShaderEffect(effect);
 535   effect.Reset();
 536
 537   Stage::GetCurrent().Add(actor);
 538
 539   // do an update / render cycle
 540   application.SendNotification();
 541   application.Render(16);
 542   application.SendNotification();
 543   application.Render(16);
 544   application.SendNotification();
 545   application.Render(16);
 546
 547   printf("removing image actor from stage and Reseting handle\n");
 548   Stage::GetCurrent().Remove(actor);
 549   actor.Reset();
 550
 551   tet_printf("### Update & Render  \n");
 552
 553   application.SendNotification();
 554   application.Render(16);
 555
 556   tet_printf("#### Update Only  \n");
 557
 558   tet_printf("effectImage.Reset \n");
 559
 560   // this releases the effect texture resource,
 561   // Update will send a DispatchDiscardTexture message to render
 562   effectImage.Reset();
 563   application.SendNotification();
 564   application.UpdateOnly(16);
 565
 566   tet_printf("#### Update Only \n");
 567
 568   // at this point shader is deleted, during clear discard queue
 569   // and it sends a Shader:: DispatchRemoveObserver message to render thread
 570   application.UpdateOnly(16);
 571
 572   tet_printf("#### Render Only  \n");
 573   // This is where it used to crash, there is a message in the queue to perform DispatchDiscardTexture
 574   // which tries to call observer->TextureDiscarded, where observer == shader that was deleted
 575   // in previous update.
 576   application.RenderOnly();
 577
 578
 579   // process the discard texture message
 580   application.RenderOnly();
 581   application.SendNotification();
 582   application.Render(16);
 583
 584   tet_result(TET_PASS);
 585
 586   END_TEST;
 587 }
 588
 589 int UtcDaliShaderEffectMethodApplyConstraint(void)
 590 {
 591   // Test whether Shader's uniform can be constrained to a stationary constraint.
 592   TestApplication application;
 593
 594   ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 595   DALI_TEST_CHECK( effect );
 596
 597   BitmapImage image = CreateBitmapImage();
 598
 599   effect.SetUniform( "uVec3", Vector3( 1.0f, 2.0f, 3.0f ) );
 600
 601   ImageActor actor = ImageActor::New( image );
 602   actor.SetSize( 100.0f, 100.0f );
 603   actor.SetName("TestImageFilenameActor");
 604   actor.SetShaderEffect(effect);
 605   Stage::GetCurrent().Add(actor);
 606
 607   Property::Index uVecProperty = effect.GetPropertyIndex("uVec3");
 608
 609   application.SendNotification();
 610   application.Render();
 611
 612   // Test effects of SetUniform...
 613   DALI_TEST_CHECK(
 614       application.GetGlAbstraction().CheckUniformValue(
 615           "uVec3", Vector3( 1.0f, 2.0f, 3.0f ) ) );
 616
 617   Constraint constraint = Constraint::New<Vector3>( uVecProperty,
 618                                                     TestConstraintToVector3(Vector3(4.0f, 9.0f, 16.0f)) );
 619
 620   effect.ApplyConstraint(constraint);
 621
 622   application.SendNotification();
 623   application.Render();
 624
 625   // Test effects of Constraint.
 626   DALI_TEST_CHECK(
 627       application.GetGlAbstraction().CheckUniformValue(
 628           "uVec3", Vector3( 4.0f, 9.0f, 16.0f ) ) );
 629   END_TEST;
 630 }
 631
 632
 633 int UtcDaliShaderEffectMethodApplyConstraintFromActor(void)
 634 {
 635   // Test whether Shader's uniform can be constrained to Actor's position.
 636   TestApplication application;
 637
 638   const Vector3 targetPosition = Vector3( 100.0f, 70.0f, 20.0f);
 639
 640   ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 641   DALI_TEST_CHECK( effect );
 642
 643   BitmapImage image = CreateBitmapImage();
 644
 645   effect.SetUniform( "uVec3", Vector3( 50.0f, 25.0f, 0.0f ) );
 646
 647   ImageActor actor = ImageActor::New( image );
 648   actor.SetPosition(targetPosition);
 649   actor.SetSize( 100.0f, 100.0f );
 650   actor.SetName("TestImageFilenameActor");
 651   actor.SetShaderEffect(effect);
 652   Stage::GetCurrent().Add(actor);
 653
 654   Property::Index uVecProperty = effect.GetPropertyIndex("uVec3");
 655
 656   Constraint constraint = Constraint::New<Vector3>( uVecProperty,
 657                                                     Source(actor, Actor::POSITION),
 658                                                     TestConstraintFromPositionToVector3() );
 659
 660   effect.ApplyConstraint(constraint);
 661
 662   application.SendNotification();
 663   application.Render();
 664
 665   // Test effects of Constraint.
 666   DALI_TEST_CHECK(
 667       application.GetGlAbstraction().CheckUniformValue(
 668           "uVec3", targetPosition ) );
 669   END_TEST;
 670 }
 671
 672 int UtcDaliShaderEffectMethodApplyConstraintFromActor2(void)
 673 {
 674   // Test whether Shader's uniform can be constrained to Actor's position.
 675   // While Actor's position is constrained to another point * 2.0f
 676   TestApplication application;
 677
 678   const Vector3 targetPosition = Vector3( 25.0f, 36.0f, 49.0f );
 679
 680   ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 681   DALI_TEST_CHECK( effect );
 682
 683   BitmapImage image = CreateBitmapImage();
 684
 685   effect.SetUniform( "uVec3", Vector3( 50.0f, 25.0f, 0.0f ) );
 686
 687   ImageActor actor = ImageActor::New( image );
 688   actor.SetPosition(Vector3( 100.0f, 70.0f, 20.0f));
 689   actor.SetSize( 100.0f, 100.0f );
 690   actor.SetName("TestImageFilenameActor");
 691   actor.SetShaderEffect(effect);
 692   Stage::GetCurrent().Add(actor);
 693
 694   Property::Index uVecProperty = effect.GetPropertyIndex("uVec3");
 695
 696   Constraint shaderConstraint = Constraint::New<Vector3>( uVecProperty,
 697                                                     Source(actor, Actor::POSITION),
 698                                                     TestConstraintFromPositionToVector3() );
 699
 700   effect.ApplyConstraint(shaderConstraint);
 701
 702   Constraint actorConstraint = Constraint::New<Vector3>( Actor::POSITION,
 703                                                          TestConstraintToVector3Double(targetPosition) );
 704
 705   actor.ApplyConstraint(actorConstraint);
 706
 707   application.SendNotification();
 708   application.Render();
 709
 710   // Test effects of Constraint.
 711   DALI_TEST_CHECK(
 712       application.GetGlAbstraction().CheckUniformValue(
 713           "uVec3", targetPosition * 2.0f ) );
 714   END_TEST;
 715 }
 716
 717 int UtcDaliShaderEffectMethodApplyConstraintCallback(void)
 718 {
 719   // Test whether Shader's uniform can be constrained to a stationary constraint.
 720   TestApplication application;
 721
 722   ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 723   DALI_TEST_CHECK( effect );
 724
 725   BitmapImage image = CreateBitmapImage();
 726
 727   effect.SetUniform( "uVec3", Vector3( 1.0f, 2.0f, 3.0f ) );
 728
 729   ImageActor actor = ImageActor::New( image );
 730   actor.SetSize( 100.0f, 100.0f );
 731   actor.SetName("TestImageFilenameActor");
 732   actor.SetShaderEffect(effect);
 733   Stage::GetCurrent().Add(actor);
 734
 735   Property::Index uVecProperty = effect.GetPropertyIndex("uVec3");
 736
 737   application.SendNotification();
 738   application.Render();
 739
 740   // Test effects of SetUniform...
 741   DALI_TEST_CHECK(
 742       application.GetGlAbstraction().CheckUniformValue(
 743           "uVec3", Vector3( 1.0f, 2.0f, 3.0f ) ) );
 744
 745   Constraint constraint = Constraint::New<Vector3>( uVecProperty,
 746                                                     TestConstraintToVector3(Vector3(4.0f, 9.0f, 16.0f)) );
 747
 748   constraint.SetApplyTime( 10.0f );
 749
 750   bool constraintCheck( false );
 751   ConstraintAppliedCheck appliedCheck( constraintCheck );
 752
 753   // We should receive the "Applied" signal after 10 seconds
 754   ActiveConstraint active = effect.ApplyConstraint(constraint);
 755   active.AppliedSignal().Connect( &application, appliedCheck );
 756
 757   application.SendNotification();
 758   application.Render(static_cast<unsigned int>(1000.0f)); // 1 elapsed second
 759
 760   // Check signal has not fired
 761   application.SendNotification();
 762   appliedCheck.CheckSignalNotReceived();
 763
 764   application.Render(static_cast<unsigned int>(4000.0f)); // 5 elapsed seconds
 765
 766   // Check signal has not fired
 767   application.SendNotification();
 768   appliedCheck.CheckSignalNotReceived();
 769
 770   application.Render(static_cast<unsigned int>(5000.0f - 1.0f)); // <10 elapsed seconds
 771
 772   // Check signal has not fired
 773   application.SendNotification();
 774   appliedCheck.CheckSignalNotReceived();
 775
 776   application.Render(static_cast<unsigned int>(2.0f)); // >10 elapsed seconds
 777
 778   // Signal should have fired
 779   application.SendNotification();
 780   appliedCheck.CheckSignalReceived();
 781
 782   // Test effects of Constraint.
 783   DALI_TEST_CHECK(
 784       application.GetGlAbstraction().CheckUniformValue(
 785           "uVec3", Vector3( 4.0f, 9.0f, 16.0f ) ) );
 786   END_TEST;
 787 }
 788
 789 int UtcDaliShaderEffectMethodRemoveConstraints(void)
 790 {
 791   // Test if constrains can be removed before they are ever applyed.
 792   TestApplication application;
 793
 794   ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 795   DALI_TEST_CHECK( effect );
 796
 797   BitmapImage image = CreateBitmapImage();
 798
 799   effect.SetUniform( "uVec3", Vector3( 1.0f, 2.0f, 3.0f ) );
 800
 801   ImageActor actor = ImageActor::New( image );
 802   actor.SetSize( 100.0f, 100.0f );
 803   actor.SetName("TestImageFilenameActor");
 804   actor.SetShaderEffect(effect);
 805   Stage::GetCurrent().Add(actor);
 806
 807   Property::Index uVecProperty = effect.GetPropertyIndex("uVec3");
 808
 809   application.SendNotification();
 810   application.Render();
 811
 812   // Test effects of SetUniform...
 813   DALI_TEST_CHECK(
 814       application.GetGlAbstraction().CheckUniformValue(
 815           "uVec3", Vector3( 1.0f, 2.0f, 3.0f ) ) );
 816
 817   Constraint constraint = Constraint::New<Vector3>( uVecProperty,
 818                                                     TestConstraintToVector3(Vector3(4.0f, 9.0f, 16.0f)) );
 819
 820   effect.ApplyConstraint(constraint);
 821
 822   // Remove the constraints
 823   effect.RemoveConstraints();
 824
 825   application.SendNotification();
 826   application.Render();
 827
 828   // Test effects of Constraint.
 829   DALI_TEST_CHECK(
 830       application.GetGlAbstraction().CheckUniformValue(
 831           "uVec3", Vector3( 1.0f, 2.0f, 3.0f ) ) );
 832   END_TEST;
 833 }
 834
 835 int UtcDaliShaderEffectMethodRemoveConstraints2(void)
 836 {
 837   // Test whether Shader's uniform constrains can be removed after they are applyed.
 838   TestApplication application;
 839
 840   ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 841   DALI_TEST_CHECK( effect );
 842
 843   BitmapImage image = CreateBitmapImage();
 844
 845   effect.SetUniform( "uVec3", Vector3( 1.0f, 2.0f, 3.0f ) );
 846
 847   ImageActor actor = ImageActor::New( image );
 848   actor.SetSize( 100.0f, 100.0f );
 849   actor.SetName("TestImageFilenameActor");
 850   actor.SetShaderEffect(effect);
 851   Stage::GetCurrent().Add(actor);
 852
 853   Property::Index uVecProperty = effect.GetPropertyIndex("uVec3");
 854
 855   application.SendNotification();
 856   application.Render();
 857
 858   // Test effects of SetUniform...
 859   DALI_TEST_CHECK(
 860       application.GetGlAbstraction().CheckUniformValue(
 861           "uVec3", Vector3( 1.0f, 2.0f, 3.0f ) ) );
 862
 863   Constraint constraint = Constraint::New<Vector3>( uVecProperty,
 864                                                     TestConstraintToVector3(Vector3(4.0f, 9.0f, 16.0f)) );
 865
 866   effect.ApplyConstraint(constraint);
 867
 868   application.SendNotification();
 869   application.Render();
 870
 871   // Reset the value and remove the constraints
 872   effect.SetUniform( "uVec3", Vector3( 1.0f, 2.0f, 3.0f ) );
 873   effect.RemoveConstraints();
 874
 875   application.SendNotification();
 876   application.Render();
 877
 878   // Test effects of Constraint.
 879   DALI_TEST_CHECK(
 880       application.GetGlAbstraction().CheckUniformValue(
 881           "uVec3", Vector3( 1.0f, 2.0f, 3.0f ) ) );
 882   END_TEST;
 883 }
 884
 885 int UtcDaliShaderEffectMethodCreateExtension(void)
 886 {
 887   // Test creation of a shader extension
 888   TestApplication aplication;
 889
 890   bool deleted;
 891   {
 892     ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 893     DALI_TEST_CHECK( effect );
 894
 895     TestExtension* extension = new TestExtension ( deleted );
 896
 897     effect.AttachExtension( extension );
 898
 899     DALI_TEST_CHECK( static_cast<TestExtension&>(effect.GetExtension()).IsAlive() );
 900   }
 901
 902   DALI_TEST_CHECK( deleted );
 903   END_TEST;
 904 }
 905
 906 int UtcDaliShaderEffectMethodCreateExtension2(void)
 907 {
 908   // Test creation of a shader extension
 909   bool deleted;
 910   {
 911     TestApplication application;
 912
 913     ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 914     DALI_TEST_CHECK( effect );
 915
 916     BitmapImage image = CreateBitmapImage();
 917
 918     effect.SetUniform( "uFloat", 1.0f );
 919
 920     ImageActor actor = ImageActor::New( image );
 921     actor.SetSize( 100.0f, 100.0f );
 922     actor.SetName("TestImageFilenameActor");
 923     actor.SetShaderEffect(effect);
 924     Stage::GetCurrent().Add(actor);
 925
 926     application.SendNotification();
 927     application.Render();
 928
 929     TestExtension* extension = new TestExtension ( deleted );
 930
 931     effect.AttachExtension( extension );
 932
 933     const ShaderEffect& constEffect(effect);
 934     const TestExtension& ext( static_cast<const TestExtension&>(constEffect.GetExtension()) );
 935
 936     DALI_TEST_CHECK( ext.IsAlive() );
 937   }
 938
 939   DALI_TEST_CHECK( deleted );
 940   END_TEST;
 941 }
 942
 943 int UtcDaliShaderEffectMethodNoExtension(void)
 944 {
 945   TestApplication application;
 946
 947   ShaderEffect effect;
 948
 949   try
 950   {
 951     ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 952     DALI_TEST_CHECK( effect );
 953
 954     // Don't attach extension
 955     ShaderEffect::Extension& extension = effect.GetExtension();
 956     (void) extension;
 957
 958     DALI_TEST_CHECK( false );
 959   }
 960   catch (Dali::DaliException& e)
 961   {
 962     // Tests that a negative test of an assertion succeeds
 963     tet_printf("Assertion %s failed at %s\n", e.mCondition.c_str(), e.mLocation.c_str());
 964     DALI_TEST_CHECK( !effect );
 965   }
 966   END_TEST;
 967 }
 968
 969
 970 int UtcDaliShaderEffectPropertyIndices(void)
 971 {
 972   TestApplication application;
 973   ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 974
 975   Property::IndexContainer indices;
 976   effect.GetPropertyIndices( indices );
 977   DALI_TEST_CHECK( ! indices.empty() );
 978   DALI_TEST_EQUALS( indices.size(), effect.GetPropertyCount(), TEST_LOCATION );
 979   END_TEST;
 980 }