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    // create a new shader effect
 285    // the vertex and fragment shader will be cached in the ShaderFactory
 286    ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 287
 288    // destroy the shader effect
 289    effect.Reset();
 290
 291    // Create the same shader effect again, this should now use the cached version
 292    // held in the shader factory
 293    effect= ShaderEffect::New( VertexSource, FragmentSource );
 294
 295    // Compile the shader effect
 296    application.SendNotification();
 297    application.Render();
 298
 299    GLuint lastShaderCompiled = application.GetGlAbstraction().GetLastShaderCompiled();
 300
 301    // get the vertex shader (compiled before fragment shader).
 302    // this last shaders compiled is for text.
 303    GLuint vertexShaderId = lastShaderCompiled - 1;
 304
 305    // compare the vertex shader sent to be compiled, with the shader string that ended up being compiled
 306    // this is to confirm the string hasn't been deleted / corrupted.
 307    std::string actualVertexShader = application.GetGlAbstraction().GetShaderSource( vertexShaderId );
 308    DALI_TEST_EQUALS( VertexSource,
 309                      actualVertexShader.substr( actualVertexShader.length() - strlen( VertexSource ) ), TEST_LOCATION );
 310
 311    END_TEST;
 312 }
 313
 314 int UtcDaliShaderEffectMethodSetUniformFloat(void)
 315 {
 316   TestApplication application;
 317
 318   ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 319   DALI_TEST_CHECK( effect );
 320
 321   BitmapImage image = CreateBitmapImage();
 322
 323   effect.SetUniform( "uFloat", 1.0f );
 324
 325   ImageActor actor = ImageActor::New( image );
 326   actor.SetSize( 100.0f, 100.0f );
 327   actor.SetName("TestImageFilenameActor");
 328   actor.SetShaderEffect(effect);
 329   Stage::GetCurrent().Add(actor);
 330
 331   application.SendNotification();
 332   application.Render();
 333
 334   DALI_TEST_CHECK(
 335       application.GetGlAbstraction().CheckUniformValue(
 336           "uFloat", 1.0f ) );
 337   END_TEST;
 338 }
 339
 340 int UtcDaliShaderEffectMethodSetUniformVector2(void)
 341 {
 342   TestApplication application;
 343
 344   ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 345   DALI_TEST_CHECK( effect );
 346
 347   BitmapImage image = CreateBitmapImage();
 348
 349   effect.SetUniform( "uVec2", Vector2( 2.0f, 3.0f ) );
 350
 351   ImageActor actor = ImageActor::New( image );
 352   actor.SetSize( 100.0f, 100.0f );
 353   actor.SetName("TestImageFilenameActor");
 354   actor.SetShaderEffect(effect);
 355   Stage::GetCurrent().Add(actor);
 356
 357   application.SendNotification();
 358   application.Render();
 359
 360   DALI_TEST_CHECK(
 361       application.GetGlAbstraction().CheckUniformValue(
 362           "uVec2", Vector2( 2.0f, 3.0f ) ) );
 363   END_TEST;
 364 }
 365
 366 int UtcDaliShaderEffectMethodSetUniformVector3(void)
 367 {
 368   TestApplication application;
 369
 370   ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 371   DALI_TEST_CHECK( effect );
 372
 373   BitmapImage image = CreateBitmapImage();
 374
 375   effect.SetUniform( "uVec3", Vector3( 4.0f, 5.0f, 6.0f ) );
 376
 377   ImageActor actor = ImageActor::New( image );
 378   actor.SetSize( 100.0f, 100.0f );
 379   actor.SetName("TestImageFilenameActor");
 380   actor.SetShaderEffect(effect);
 381   Stage::GetCurrent().Add(actor);
 382
 383   application.SendNotification();
 384   application.Render();
 385
 386   DALI_TEST_CHECK(
 387       application.GetGlAbstraction().CheckUniformValue(
 388           "uVec3", Vector3( 4.0f, 5.0f, 6.0f ) ) );
 389   END_TEST;
 390 }
 391
 392 int UtcDaliShaderEffectMethodSetUniformVector4(void)
 393 {
 394   TestApplication application;
 395
 396   ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 397   DALI_TEST_CHECK( effect );
 398
 399   BitmapImage image = CreateBitmapImage();
 400
 401   effect.SetUniform( "uVec4", Vector4( 7.0f, 8.0f, 9.0f, 10.0f ) );
 402
 403   ImageActor actor = ImageActor::New( image );
 404   actor.SetSize( 100.0f, 100.0f );
 405   actor.SetName("TestImageFilenameActor");
 406   actor.SetShaderEffect(effect);
 407   Stage::GetCurrent().Add(actor);
 408
 409   application.SendNotification();
 410   application.Render();
 411
 412   DALI_TEST_CHECK(
 413       application.GetGlAbstraction().CheckUniformValue(
 414           "uVec4", Vector4( 7.0f, 8.0f, 9.0f, 10.0f ) ) );
 415   END_TEST;
 416 }
 417
 418 int UtcDaliShaderEffectMethodSetUniformMatrix(void)
 419 {
 420   TestApplication application;
 421
 422   ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 423   DALI_TEST_CHECK( effect );
 424
 425   BitmapImage image = CreateBitmapImage();
 426
 427   effect.SetUniform( "uModelView", Matrix::IDENTITY );
 428
 429   ImageActor actor = ImageActor::New( image );
 430   actor.SetSize( 100.0f, 100.0f );
 431   actor.SetName("TestImageFilenameActor");
 432   actor.SetShaderEffect(effect);
 433   Stage::GetCurrent().Add(actor);
 434
 435   application.SendNotification();
 436   application.Render();
 437
 438   DALI_TEST_CHECK(
 439       application.GetGlAbstraction().CheckUniformValue(
 440           "uModelView", Matrix::IDENTITY ) );
 441   END_TEST;
 442 }
 443
 444 int UtcDaliShaderEffectMethodSetUniformMatrix3(void)
 445 {
 446   TestApplication application;
 447
 448   ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 449   DALI_TEST_CHECK( effect );
 450
 451   BitmapImage image = CreateBitmapImage();
 452
 453   Matrix3 matIdentity(1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f);
 454   effect.SetUniform( "uMatrix3", matIdentity );
 455
 456   ImageActor actor = ImageActor::New( image );
 457   actor.SetSize( 100.0f, 100.0f );
 458   actor.SetName("TestImageFilenameActor");
 459   actor.SetShaderEffect(effect);
 460   Stage::GetCurrent().Add(actor);
 461
 462   application.SendNotification();
 463   application.Render();
 464
 465   DALI_TEST_CHECK( application.GetGlAbstraction().CheckUniformValue("uMatrix3", matIdentity) );
 466   END_TEST;
 467 }
 468
 469 int UtcDaliShaderEffectMethodSetUniformViewport(void)
 470 {
 471   TestApplication application;
 472
 473   ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 474   DALI_TEST_CHECK( effect );
 475
 476   BitmapImage image = CreateBitmapImage();
 477
 478   ImageActor actor = ImageActor::New( image );
 479   actor.SetSize( 100.0f, 100.0f );
 480   actor.SetName("TestImageFilenameActor");
 481   actor.SetShaderEffect(effect);
 482   Stage::GetCurrent().Add(actor);
 483
 484   effect.SetUniform( "uVec2", Vector2( 0.0f, 0.0f ), ShaderEffect::COORDINATE_TYPE_VIEWPORT_POSITION );
 485   effect.SetUniform( "uVec2Dir", Vector2( 1.0f, 2.0f ), ShaderEffect::COORDINATE_TYPE_VIEWPORT_DIRECTION );
 486
 487   application.SendNotification();
 488   application.Render();
 489
 490   const Vector2& stageSize(Stage::GetCurrent().GetSize());
 491
 492   DALI_TEST_CHECK(
 493       application.GetGlAbstraction().CheckUniformValue(
 494           "uVec2", Vector2( stageSize.x/2, -stageSize.y/2 ) ) );
 495
 496   DALI_TEST_CHECK(
 497       application.GetGlAbstraction().CheckUniformValue(
 498           "uVec2Dir", Vector2( -1.0f, 2.0f ) ) );
 499   END_TEST;
 500 }
 501
 502 int UtcDaliShaderEffectMethodSetEffectImage(void)
 503 {
 504   TestApplication application;
 505
 506   ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 507   DALI_TEST_CHECK( effect );
 508
 509   BitmapImage image = CreateBitmapImage();
 510
 511   effect.SetEffectImage(image);
 512
 513   ImageActor actor = ImageActor::New( image );
 514   actor.SetSize( 100.0f, 100.0f );
 515   actor.SetName("TestImageFilenameActor");
 516   actor.SetShaderEffect(effect);
 517   Stage::GetCurrent().Add(actor);
 518
 519   application.SendNotification();
 520   application.Render(16);
 521   application.SendNotification();
 522   application.Render(16);
 523   application.SendNotification();
 524
 525   DALI_TEST_CHECK( application.GetGlAbstraction().CheckUniformValue( "sEffect", 1 ) );
 526   END_TEST;
 527 }
 528
 529 int UtcDaliShaderEffectMethodSetEffectImageAndDelete(void)
 530 {
 531   TestApplication application;
 532
 533   ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 534
 535   BitmapImage effectImage = CreateBitmapImage();
 536   effect.SetEffectImage(effectImage);
 537
 538   ImageActor actor = ImageActor::New();
 539
 540   actor.SetShaderEffect(effect);
 541   effect.Reset();
 542
 543   Stage::GetCurrent().Add(actor);
 544
 545   // do an update / render cycle
 546   application.SendNotification();
 547   application.Render(16);
 548   application.SendNotification();
 549   application.Render(16);
 550   application.SendNotification();
 551   application.Render(16);
 552
 553   printf("removing image actor from stage and Reseting handle\n");
 554   Stage::GetCurrent().Remove(actor);
 555   actor.Reset();
 556
 557   tet_printf("### Update & Render  \n");
 558
 559   application.SendNotification();
 560   application.Render(16);
 561
 562   tet_printf("#### Update Only  \n");
 563
 564   tet_printf("effectImage.Reset \n");
 565
 566   // this releases the effect texture resource,
 567   // Update will send a DispatchDiscardTexture message to render
 568   effectImage.Reset();
 569   application.SendNotification();
 570   application.UpdateOnly(16);
 571
 572   tet_printf("#### Update Only \n");
 573
 574   // at this point shader is deleted, during clear discard queue
 575   // and it sends a Shader:: DispatchRemoveObserver message to render thread
 576   application.UpdateOnly(16);
 577
 578   tet_printf("#### Render Only  \n");
 579   // This is where it used to crash, there is a message in the queue to perform DispatchDiscardTexture
 580   // which tries to call observer->TextureDiscarded, where observer == shader that was deleted
 581   // in previous update.
 582   application.RenderOnly();
 583
 584
 585   // process the discard texture message
 586   application.RenderOnly();
 587   application.SendNotification();
 588   application.Render(16);
 589
 590   tet_result(TET_PASS);
 591
 592   END_TEST;
 593 }
 594
 595 int UtcDaliShaderEffectMethodApplyConstraint(void)
 596 {
 597   // Test whether Shader's uniform can be constrained to a stationary constraint.
 598   TestApplication application;
 599
 600   ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 601   DALI_TEST_CHECK( effect );
 602
 603   BitmapImage image = CreateBitmapImage();
 604
 605   effect.SetUniform( "uVec3", Vector3( 1.0f, 2.0f, 3.0f ) );
 606
 607   ImageActor actor = ImageActor::New( image );
 608   actor.SetSize( 100.0f, 100.0f );
 609   actor.SetName("TestImageFilenameActor");
 610   actor.SetShaderEffect(effect);
 611   Stage::GetCurrent().Add(actor);
 612
 613   Property::Index uVecProperty = effect.GetPropertyIndex("uVec3");
 614
 615   application.SendNotification();
 616   application.Render();
 617
 618   // Test effects of SetUniform...
 619   DALI_TEST_CHECK(
 620       application.GetGlAbstraction().CheckUniformValue(
 621           "uVec3", Vector3( 1.0f, 2.0f, 3.0f ) ) );
 622
 623   Constraint constraint = Constraint::New<Vector3>( uVecProperty,
 624                                                     TestConstraintToVector3(Vector3(4.0f, 9.0f, 16.0f)) );
 625
 626   effect.ApplyConstraint(constraint);
 627
 628   application.SendNotification();
 629   application.Render();
 630
 631   // Test effects of Constraint.
 632   DALI_TEST_CHECK(
 633       application.GetGlAbstraction().CheckUniformValue(
 634           "uVec3", Vector3( 4.0f, 9.0f, 16.0f ) ) );
 635   END_TEST;
 636 }
 637
 638
 639 int UtcDaliShaderEffectMethodApplyConstraintFromActor(void)
 640 {
 641   // Test whether Shader's uniform can be constrained to Actor's position.
 642   TestApplication application;
 643
 644   const Vector3 targetPosition = Vector3( 100.0f, 70.0f, 20.0f);
 645
 646   ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 647   DALI_TEST_CHECK( effect );
 648
 649   BitmapImage image = CreateBitmapImage();
 650
 651   effect.SetUniform( "uVec3", Vector3( 50.0f, 25.0f, 0.0f ) );
 652
 653   ImageActor actor = ImageActor::New( image );
 654   actor.SetPosition(targetPosition);
 655   actor.SetSize( 100.0f, 100.0f );
 656   actor.SetName("TestImageFilenameActor");
 657   actor.SetShaderEffect(effect);
 658   Stage::GetCurrent().Add(actor);
 659
 660   Property::Index uVecProperty = effect.GetPropertyIndex("uVec3");
 661
 662   Constraint constraint = Constraint::New<Vector3>( uVecProperty,
 663                                                     Source(actor, Actor::POSITION),
 664                                                     TestConstraintFromPositionToVector3() );
 665
 666   effect.ApplyConstraint(constraint);
 667
 668   application.SendNotification();
 669   application.Render();
 670
 671   // Test effects of Constraint.
 672   DALI_TEST_CHECK(
 673       application.GetGlAbstraction().CheckUniformValue(
 674           "uVec3", targetPosition ) );
 675   END_TEST;
 676 }
 677
 678 int UtcDaliShaderEffectMethodApplyConstraintFromActor2(void)
 679 {
 680   // Test whether Shader's uniform can be constrained to Actor's position.
 681   // While Actor's position is constrained to another point * 2.0f
 682   TestApplication application;
 683
 684   const Vector3 targetPosition = Vector3( 25.0f, 36.0f, 49.0f );
 685
 686   ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 687   DALI_TEST_CHECK( effect );
 688
 689   BitmapImage image = CreateBitmapImage();
 690
 691   effect.SetUniform( "uVec3", Vector3( 50.0f, 25.0f, 0.0f ) );
 692
 693   ImageActor actor = ImageActor::New( image );
 694   actor.SetPosition(Vector3( 100.0f, 70.0f, 20.0f));
 695   actor.SetSize( 100.0f, 100.0f );
 696   actor.SetName("TestImageFilenameActor");
 697   actor.SetShaderEffect(effect);
 698   Stage::GetCurrent().Add(actor);
 699
 700   Property::Index uVecProperty = effect.GetPropertyIndex("uVec3");
 701
 702   Constraint shaderConstraint = Constraint::New<Vector3>( uVecProperty,
 703                                                     Source(actor, Actor::POSITION),
 704                                                     TestConstraintFromPositionToVector3() );
 705
 706   effect.ApplyConstraint(shaderConstraint);
 707
 708   Constraint actorConstraint = Constraint::New<Vector3>( Actor::POSITION,
 709                                                          TestConstraintToVector3Double(targetPosition) );
 710
 711   actor.ApplyConstraint(actorConstraint);
 712
 713   application.SendNotification();
 714   application.Render();
 715
 716   // Test effects of Constraint.
 717   DALI_TEST_CHECK(
 718       application.GetGlAbstraction().CheckUniformValue(
 719           "uVec3", targetPosition * 2.0f ) );
 720   END_TEST;
 721 }
 722
 723 int UtcDaliShaderEffectMethodApplyConstraintCallback(void)
 724 {
 725   // Test whether Shader's uniform can be constrained to a stationary constraint.
 726   TestApplication application;
 727
 728   ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 729   DALI_TEST_CHECK( effect );
 730
 731   BitmapImage image = CreateBitmapImage();
 732
 733   effect.SetUniform( "uVec3", Vector3( 1.0f, 2.0f, 3.0f ) );
 734
 735   ImageActor actor = ImageActor::New( image );
 736   actor.SetSize( 100.0f, 100.0f );
 737   actor.SetName("TestImageFilenameActor");
 738   actor.SetShaderEffect(effect);
 739   Stage::GetCurrent().Add(actor);
 740
 741   Property::Index uVecProperty = effect.GetPropertyIndex("uVec3");
 742
 743   application.SendNotification();
 744   application.Render();
 745
 746   // Test effects of SetUniform...
 747   DALI_TEST_CHECK(
 748       application.GetGlAbstraction().CheckUniformValue(
 749           "uVec3", Vector3( 1.0f, 2.0f, 3.0f ) ) );
 750
 751   Constraint constraint = Constraint::New<Vector3>( uVecProperty,
 752                                                     TestConstraintToVector3(Vector3(4.0f, 9.0f, 16.0f)) );
 753
 754   constraint.SetApplyTime( 10.0f );
 755
 756   bool constraintCheck( false );
 757   ConstraintAppliedCheck appliedCheck( constraintCheck );
 758
 759   // We should receive the "Applied" signal after 10 seconds
 760   ActiveConstraint active = effect.ApplyConstraint(constraint);
 761   active.AppliedSignal().Connect( &application, appliedCheck );
 762
 763   application.SendNotification();
 764   application.Render(static_cast<unsigned int>(1000.0f)); // 1 elapsed second
 765
 766   // Check signal has not fired
 767   application.SendNotification();
 768   appliedCheck.CheckSignalNotReceived();
 769
 770   application.Render(static_cast<unsigned int>(4000.0f)); // 5 elapsed seconds
 771
 772   // Check signal has not fired
 773   application.SendNotification();
 774   appliedCheck.CheckSignalNotReceived();
 775
 776   application.Render(static_cast<unsigned int>(5000.0f - 1.0f)); // <10 elapsed seconds
 777
 778   // Check signal has not fired
 779   application.SendNotification();
 780   appliedCheck.CheckSignalNotReceived();
 781
 782   application.Render(static_cast<unsigned int>(2.0f)); // >10 elapsed seconds
 783
 784   // Signal should have fired
 785   application.SendNotification();
 786   appliedCheck.CheckSignalReceived();
 787
 788   // Test effects of Constraint.
 789   DALI_TEST_CHECK(
 790       application.GetGlAbstraction().CheckUniformValue(
 791           "uVec3", Vector3( 4.0f, 9.0f, 16.0f ) ) );
 792   END_TEST;
 793 }
 794
 795 int UtcDaliShaderEffectMethodRemoveConstraints(void)
 796 {
 797   // Test if constrains can be removed before they are ever applyed.
 798   TestApplication application;
 799
 800   ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 801   DALI_TEST_CHECK( effect );
 802
 803   BitmapImage image = CreateBitmapImage();
 804
 805   effect.SetUniform( "uVec3", Vector3( 1.0f, 2.0f, 3.0f ) );
 806
 807   ImageActor actor = ImageActor::New( image );
 808   actor.SetSize( 100.0f, 100.0f );
 809   actor.SetName("TestImageFilenameActor");
 810   actor.SetShaderEffect(effect);
 811   Stage::GetCurrent().Add(actor);
 812
 813   Property::Index uVecProperty = effect.GetPropertyIndex("uVec3");
 814
 815   application.SendNotification();
 816   application.Render();
 817
 818   // Test effects of SetUniform...
 819   DALI_TEST_CHECK(
 820       application.GetGlAbstraction().CheckUniformValue(
 821           "uVec3", Vector3( 1.0f, 2.0f, 3.0f ) ) );
 822
 823   Constraint constraint = Constraint::New<Vector3>( uVecProperty,
 824                                                     TestConstraintToVector3(Vector3(4.0f, 9.0f, 16.0f)) );
 825
 826   effect.ApplyConstraint(constraint);
 827
 828   // Remove the constraints
 829   effect.RemoveConstraints();
 830
 831   application.SendNotification();
 832   application.Render();
 833
 834   // Test effects of Constraint.
 835   DALI_TEST_CHECK(
 836       application.GetGlAbstraction().CheckUniformValue(
 837           "uVec3", Vector3( 1.0f, 2.0f, 3.0f ) ) );
 838   END_TEST;
 839 }
 840
 841 int UtcDaliShaderEffectMethodRemoveConstraints2(void)
 842 {
 843   // Test whether Shader's uniform constrains can be removed after they are applyed.
 844   TestApplication application;
 845
 846   ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 847   DALI_TEST_CHECK( effect );
 848
 849   BitmapImage image = CreateBitmapImage();
 850
 851   effect.SetUniform( "uVec3", Vector3( 1.0f, 2.0f, 3.0f ) );
 852
 853   ImageActor actor = ImageActor::New( image );
 854   actor.SetSize( 100.0f, 100.0f );
 855   actor.SetName("TestImageFilenameActor");
 856   actor.SetShaderEffect(effect);
 857   Stage::GetCurrent().Add(actor);
 858
 859   Property::Index uVecProperty = effect.GetPropertyIndex("uVec3");
 860
 861   application.SendNotification();
 862   application.Render();
 863
 864   // Test effects of SetUniform...
 865   DALI_TEST_CHECK(
 866       application.GetGlAbstraction().CheckUniformValue(
 867           "uVec3", Vector3( 1.0f, 2.0f, 3.0f ) ) );
 868
 869   Constraint constraint = Constraint::New<Vector3>( uVecProperty,
 870                                                     TestConstraintToVector3(Vector3(4.0f, 9.0f, 16.0f)) );
 871
 872   effect.ApplyConstraint(constraint);
 873
 874   application.SendNotification();
 875   application.Render();
 876
 877   // Reset the value and remove the constraints
 878   effect.SetUniform( "uVec3", Vector3( 1.0f, 2.0f, 3.0f ) );
 879   effect.RemoveConstraints();
 880
 881   application.SendNotification();
 882   application.Render();
 883
 884   // Test effects of Constraint.
 885   DALI_TEST_CHECK(
 886       application.GetGlAbstraction().CheckUniformValue(
 887           "uVec3", Vector3( 1.0f, 2.0f, 3.0f ) ) );
 888   END_TEST;
 889 }
 890
 891 int UtcDaliShaderEffectMethodCreateExtension(void)
 892 {
 893   // Test creation of a shader extension
 894   TestApplication aplication;
 895
 896   bool deleted;
 897   {
 898     ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 899     DALI_TEST_CHECK( effect );
 900
 901     TestExtension* extension = new TestExtension ( deleted );
 902
 903     effect.AttachExtension( extension );
 904
 905     DALI_TEST_CHECK( static_cast<TestExtension&>(effect.GetExtension()).IsAlive() );
 906   }
 907
 908   DALI_TEST_CHECK( deleted );
 909   END_TEST;
 910 }
 911
 912 int UtcDaliShaderEffectMethodCreateExtension2(void)
 913 {
 914   // Test creation of a shader extension
 915   bool deleted;
 916   {
 917     TestApplication application;
 918
 919     ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 920     DALI_TEST_CHECK( effect );
 921
 922     BitmapImage image = CreateBitmapImage();
 923
 924     effect.SetUniform( "uFloat", 1.0f );
 925
 926     ImageActor actor = ImageActor::New( image );
 927     actor.SetSize( 100.0f, 100.0f );
 928     actor.SetName("TestImageFilenameActor");
 929     actor.SetShaderEffect(effect);
 930     Stage::GetCurrent().Add(actor);
 931
 932     application.SendNotification();
 933     application.Render();
 934
 935     TestExtension* extension = new TestExtension ( deleted );
 936
 937     effect.AttachExtension( extension );
 938
 939     const ShaderEffect& constEffect(effect);
 940     const TestExtension& ext( static_cast<const TestExtension&>(constEffect.GetExtension()) );
 941
 942     DALI_TEST_CHECK( ext.IsAlive() );
 943   }
 944
 945   DALI_TEST_CHECK( deleted );
 946   END_TEST;
 947 }
 948
 949 int UtcDaliShaderEffectMethodNoExtension(void)
 950 {
 951   TestApplication application;
 952
 953   ShaderEffect effect;
 954
 955   try
 956   {
 957     ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 958     DALI_TEST_CHECK( effect );
 959
 960     // Don't attach extension
 961     ShaderEffect::Extension& extension = effect.GetExtension();
 962     (void) extension;
 963
 964     DALI_TEST_CHECK( false );
 965   }
 966   catch (Dali::DaliException& e)
 967   {
 968     // Tests that a negative test of an assertion succeeds
 969     tet_printf("Assertion %s failed at %s\n", e.mCondition.c_str(), e.mLocation.c_str());
 970     DALI_TEST_CHECK( !effect );
 971   }
 972   END_TEST;
 973 }
 974
 975
 976 int UtcDaliShaderEffectPropertyIndices(void)
 977 {
 978   TestApplication application;
 979   ShaderEffect effect = ShaderEffect::New( VertexSource, FragmentSource );
 980
 981   Property::IndexContainer indices;
 982   effect.GetPropertyIndices( indices );
 983   DALI_TEST_CHECK( ! indices.empty() );
 984   DALI_TEST_EQUALS( indices.size(), effect.GetPropertyCount(), TEST_LOCATION );
 985   END_TEST;
 986 }