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

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