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