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

   1 /*
   2  * Copyright (c) 2015 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 <dali/public-api/dali-core.h>
  19 #include <dali-test-suite-utils.h>
  20
  21 using namespace Dali;
  22
  23 #include <mesh-builder.h>
  24
  25 namespace
  26 {
  27 void TestConstraintNoBlue( Vector4& current, const PropertyInputContainer& inputs )
  28 {
  29   current.b = 0.0f;
  30 }
  31 }
  32
  33 void renderer_test_startup(void)
  34 {
  35   test_return_value = TET_UNDEF;
  36 }
  37
  38 void renderer_test_cleanup(void)
  39 {
  40   test_return_value = TET_PASS;
  41 }
  42
  43
  44 int UtcDaliRendererNew01(void)
  45 {
  46   TestApplication application;
  47
  48   Geometry geometry = CreateQuadGeometry();
  49   Material material = CreateMaterial(1.0f);
  50   Renderer renderer = Renderer::New(geometry, material);
  51
  52   DALI_TEST_EQUALS( (bool)renderer, true, TEST_LOCATION );
  53   END_TEST;
  54 }
  55
  56 int UtcDaliRendererNew02(void)
  57 {
  58   TestApplication application;
  59   Renderer renderer;
  60   DALI_TEST_EQUALS( (bool)renderer, false, TEST_LOCATION );
  61   END_TEST;
  62 }
  63
  64 int UtcDaliRendererDownCast01(void)
  65 {
  66   TestApplication application;
  67
  68   Geometry geometry = CreateQuadGeometry();
  69   Material material = CreateMaterial(1.0f);
  70   Renderer renderer = Renderer::New(geometry, material);
  71
  72   BaseHandle handle(renderer);
  73   Renderer renderer2 = Renderer::DownCast(handle);
  74   DALI_TEST_EQUALS( (bool)renderer2, true, TEST_LOCATION );
  75   END_TEST;
  76 }
  77
  78 int UtcDaliRendererDownCast02(void)
  79 {
  80   TestApplication application;
  81
  82   Handle handle = Handle::New(); // Create a custom object
  83   Renderer renderer = Renderer::DownCast(handle);
  84   DALI_TEST_EQUALS( (bool)renderer, false, TEST_LOCATION );
  85   END_TEST;
  86 }
  87
  88
  89 int UtcDaliRendererConstraint01(void)
  90 {
  91   TestApplication application;
  92
  93   tet_infoline("Test that a non-uniform renderer property can be constrained");
  94
  95   Shader shader = Shader::New("VertexSource", "FragmentSource");
  96   Material material = Material::New( shader );
  97   material.SetProperty(Material::Property::COLOR, Color::WHITE);
  98
  99   Geometry geometry = CreateQuadGeometry();
 100   Renderer renderer = Renderer::New( geometry, material );
 101
 102   Actor actor = Actor::New();
 103   actor.AddRenderer(renderer);
 104   actor.SetSize(400, 400);
 105   Stage::GetCurrent().Add(actor);
 106
 107   Vector4 initialColor = Color::WHITE;
 108   Property::Index colorIndex = renderer.RegisterProperty( "uFadeColor", initialColor );
 109
 110   application.SendNotification();
 111   application.Render(0);
 112   DALI_TEST_EQUALS( renderer.GetProperty<Vector4>(colorIndex), initialColor, TEST_LOCATION );
 113
 114   // Apply constraint
 115   Constraint constraint = Constraint::New<Vector4>( renderer, colorIndex, TestConstraintNoBlue );
 116   constraint.Apply();
 117   application.SendNotification();
 118   application.Render(0);
 119
 120   // Expect no blue component in either buffer - yellow
 121   DALI_TEST_EQUALS( renderer.GetProperty<Vector4>(colorIndex), Color::YELLOW, TEST_LOCATION );
 122   application.Render(0);
 123   DALI_TEST_EQUALS( renderer.GetProperty<Vector4>(colorIndex), Color::YELLOW, TEST_LOCATION );
 124
 125   renderer.RemoveConstraints();
 126   renderer.SetProperty(colorIndex, Color::WHITE );
 127   application.SendNotification();
 128   application.Render(0);
 129   DALI_TEST_EQUALS( renderer.GetProperty<Vector4>(colorIndex), Color::WHITE, TEST_LOCATION );
 130
 131   END_TEST;
 132 }
 133
 134 int UtcDaliRendererConstraint02(void)
 135 {
 136   TestApplication application;
 137
 138   tet_infoline("Test that a uniform map renderer property can be constrained");
 139
 140   Shader shader = Shader::New("VertexSource", "FragmentSource");
 141   Material material = Material::New( shader );
 142   material.SetProperty(Material::Property::COLOR, Color::WHITE);
 143
 144   Geometry geometry = CreateQuadGeometry();
 145   Renderer renderer = Renderer::New( geometry, material );
 146
 147   Actor actor = Actor::New();
 148   actor.AddRenderer(renderer);
 149   actor.SetSize(400, 400);
 150   Stage::GetCurrent().Add(actor);
 151   application.SendNotification();
 152   application.Render(0);
 153
 154   Vector4 initialColor = Color::WHITE;
 155   Property::Index colorIndex = renderer.RegisterProperty( "uFadeColor", initialColor );
 156
 157   TestGlAbstraction& gl = application.GetGlAbstraction();
 158
 159   application.SendNotification();
 160   application.Render(0);
 161
 162   Vector4 actualValue(Vector4::ZERO);
 163   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 164   DALI_TEST_EQUALS( actualValue, initialColor, TEST_LOCATION );
 165
 166   // Apply constraint
 167   Constraint constraint = Constraint::New<Vector4>( renderer, colorIndex, TestConstraintNoBlue );
 168   constraint.Apply();
 169   application.SendNotification();
 170   application.Render(0);
 171
 172    // Expect no blue component in either buffer - yellow
 173   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 174   DALI_TEST_EQUALS( actualValue, Color::YELLOW, TEST_LOCATION );
 175
 176   application.Render(0);
 177   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 178   DALI_TEST_EQUALS( actualValue, Color::YELLOW, TEST_LOCATION );
 179
 180   renderer.RemoveConstraints();
 181   renderer.SetProperty(colorIndex, Color::WHITE );
 182   application.SendNotification();
 183   application.Render(0);
 184
 185   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 186   DALI_TEST_EQUALS( actualValue, Color::WHITE, TEST_LOCATION );
 187
 188   END_TEST;
 189 }
 190
 191
 192
 193 int UtcDaliRendererAnimatedProperty01(void)
 194 {
 195   TestApplication application;
 196
 197   tet_infoline("Test that a non-uniform renderer property can be animated");
 198
 199   Shader shader = Shader::New("VertexSource", "FragmentSource");
 200   Material material = Material::New( shader );
 201   material.SetProperty(Material::Property::COLOR, Color::WHITE);
 202
 203   Geometry geometry = CreateQuadGeometry();
 204   Renderer renderer = Renderer::New( geometry, material );
 205
 206   Actor actor = Actor::New();
 207   actor.AddRenderer(renderer);
 208   actor.SetSize(400, 400);
 209   Stage::GetCurrent().Add(actor);
 210
 211   Vector4 initialColor = Color::WHITE;
 212   Property::Index colorIndex = renderer.RegisterProperty( "uFadeColor", initialColor );
 213
 214   application.SendNotification();
 215   application.Render(0);
 216   DALI_TEST_EQUALS( renderer.GetProperty<Vector4>(colorIndex), initialColor, TEST_LOCATION );
 217
 218   Animation  animation = Animation::New(1.0f);
 219   KeyFrames keyFrames = KeyFrames::New();
 220   keyFrames.Add(0.0f, initialColor);
 221   keyFrames.Add(1.0f, Color::TRANSPARENT);
 222   animation.AnimateBetween( Property( renderer, colorIndex ), keyFrames );
 223   animation.Play();
 224
 225   application.SendNotification();
 226   application.Render(500);
 227
 228   DALI_TEST_EQUALS( renderer.GetProperty<Vector4>(colorIndex), Color::WHITE * 0.5f, TEST_LOCATION );
 229
 230   application.Render(500);
 231
 232   DALI_TEST_EQUALS( renderer.GetProperty<Vector4>(colorIndex), Color::TRANSPARENT, TEST_LOCATION );
 233
 234   END_TEST;
 235 }
 236
 237 int UtcDaliRendererAnimatedProperty02(void)
 238 {
 239   TestApplication application;
 240
 241   tet_infoline("Test that a uniform map renderer property can be animated");
 242
 243   Shader shader = Shader::New("VertexSource", "FragmentSource");
 244   Material material = Material::New( shader );
 245   material.SetProperty(Material::Property::COLOR, Color::WHITE);
 246
 247   Geometry geometry = CreateQuadGeometry();
 248   Renderer renderer = Renderer::New( geometry, material );
 249
 250   Actor actor = Actor::New();
 251   actor.AddRenderer(renderer);
 252   actor.SetSize(400, 400);
 253   Stage::GetCurrent().Add(actor);
 254   application.SendNotification();
 255   application.Render(0);
 256
 257   Vector4 initialColor = Color::WHITE;
 258   Property::Index colorIndex = renderer.RegisterProperty( "uFadeColor", initialColor );
 259
 260   TestGlAbstraction& gl = application.GetGlAbstraction();
 261
 262   application.SendNotification();
 263   application.Render(0);
 264
 265   Vector4 actualValue(Vector4::ZERO);
 266   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 267   DALI_TEST_EQUALS( actualValue, initialColor, TEST_LOCATION );
 268
 269   Animation  animation = Animation::New(1.0f);
 270   KeyFrames keyFrames = KeyFrames::New();
 271   keyFrames.Add(0.0f, initialColor);
 272   keyFrames.Add(1.0f, Color::TRANSPARENT);
 273   animation.AnimateBetween( Property( renderer, colorIndex ), keyFrames );
 274   animation.Play();
 275
 276   application.SendNotification();
 277   application.Render(500);
 278
 279   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 280   DALI_TEST_EQUALS( actualValue, Color::WHITE * 0.5f, TEST_LOCATION );
 281
 282   application.Render(500);
 283   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 284   DALI_TEST_EQUALS( actualValue, Color::TRANSPARENT, TEST_LOCATION );
 285
 286   END_TEST;
 287 }
 288
 289
 290
 291
 292 int UtcDaliRendererUniformMapPrecendence01(void)
 293 {
 294   TestApplication application;
 295
 296   tet_infoline("Test the uniform map precedence is applied properly");
 297
 298   Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
 299   Sampler sampler = Sampler::New(image, "sTexture");
 300   sampler.SetUniformName( "sEffectTexture" );
 301
 302   Shader shader = Shader::New("VertexSource", "FragmentSource");
 303   Material material = Material::New( shader );
 304   material.AddSampler( sampler );
 305   material.SetProperty(Material::Property::COLOR, Color::WHITE);
 306
 307   PropertyBuffer vertexBuffer = CreatePropertyBuffer();
 308   Geometry geometry = CreateQuadGeometryFromBuffer(vertexBuffer);
 309   Renderer renderer = Renderer::New( geometry, material );
 310
 311   Actor actor = Actor::New();
 312   actor.AddRenderer(renderer);
 313   actor.SetSize(400, 400);
 314   Stage::GetCurrent().Add(actor);
 315   application.SendNotification();
 316   application.Render(0);
 317
 318   renderer.RegisterProperty( "uFadeColor", Color::RED );
 319
 320   actor.RegisterProperty( "uFadeColor", Color::GREEN );
 321
 322   Property::Index materialFadeColorIndex = material.RegisterProperty( "uFadeColor", Color::BLUE );
 323
 324   sampler.RegisterProperty( "uFadeColor", Color::CYAN );
 325   shader.RegisterProperty( "uFadeColor", Color::MAGENTA );
 326
 327   geometry.RegisterProperty( "uFadeColor", Color::YELLOW );
 328
 329   vertexBuffer.RegisterProperty( "uFadeColor", Color::BLACK );
 330
 331
 332   TestGlAbstraction& gl = application.GetGlAbstraction();
 333
 334   application.SendNotification();
 335   application.Render(0);
 336
 337   // Expect that the renderer's fade color property is accessed
 338   Vector4 actualValue(Vector4::ZERO);
 339   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 340   DALI_TEST_EQUALS( actualValue, Color::RED, TEST_LOCATION );
 341
 342   // Animate material's fade color property. Should be no change to uniform
 343   Animation  animation = Animation::New(1.0f);
 344   KeyFrames keyFrames = KeyFrames::New();
 345   keyFrames.Add(0.0f, Color::WHITE);
 346   keyFrames.Add(1.0f, Color::TRANSPARENT);
 347   animation.AnimateBetween( Property( material, materialFadeColorIndex ), keyFrames );
 348   animation.Play();
 349
 350   application.SendNotification();
 351   application.Render(500);
 352
 353   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 354   DALI_TEST_EQUALS( actualValue, Color::RED, TEST_LOCATION );
 355
 356   application.Render(500);
 357   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 358   DALI_TEST_EQUALS( actualValue, Color::RED, TEST_LOCATION );
 359
 360   END_TEST;
 361 }
 362
 363 int UtcDaliRendererUniformMapPrecendence02(void)
 364 {
 365   TestApplication application;
 366
 367   tet_infoline("Test the uniform map precedence is applied properly");
 368
 369   Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
 370   Sampler sampler = Sampler::New(image, "sTexture");
 371   sampler.SetUniformName( "sEffectTexture" );
 372
 373   Shader shader = Shader::New("VertexSource", "FragmentSource");
 374   Material material = Material::New( shader );
 375   material.AddSampler( sampler );
 376   material.SetProperty(Material::Property::COLOR, Color::WHITE);
 377
 378   PropertyBuffer vertexBuffer = CreatePropertyBuffer();
 379   Geometry geometry = CreateQuadGeometryFromBuffer(vertexBuffer);
 380   Renderer renderer = Renderer::New( geometry, material );
 381
 382   Actor actor = Actor::New();
 383   actor.AddRenderer(renderer);
 384   actor.SetSize(400, 400);
 385   Stage::GetCurrent().Add(actor);
 386   application.SendNotification();
 387   application.Render(0);
 388
 389   // Don't add property / uniform map to renderer
 390
 391   actor.RegisterProperty( "uFadeColor", Color::GREEN );
 392
 393   Property::Index materialFadeColorIndex = material.RegisterProperty( "uFadeColor", Color::BLUE );
 394
 395   sampler.RegisterProperty( "uFadeColor", Color::CYAN );
 396   shader.RegisterProperty( "uFadeColor", Color::MAGENTA );
 397
 398   geometry.RegisterProperty( "uFadeColor", Color::YELLOW );
 399
 400   vertexBuffer.RegisterProperty( "uFadeColor", Color::BLACK );
 401
 402
 403   TestGlAbstraction& gl = application.GetGlAbstraction();
 404
 405   application.SendNotification();
 406   application.Render(0);
 407
 408   // Expect that the actor's fade color property is accessed
 409   Vector4 actualValue(Vector4::ZERO);
 410   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 411   DALI_TEST_EQUALS( actualValue, Color::GREEN, TEST_LOCATION );
 412
 413   // Animate material's fade color property. Should be no change to uniform
 414   Animation  animation = Animation::New(1.0f);
 415   KeyFrames keyFrames = KeyFrames::New();
 416   keyFrames.Add(0.0f, Color::WHITE);
 417   keyFrames.Add(1.0f, Color::TRANSPARENT);
 418   animation.AnimateBetween( Property( material, materialFadeColorIndex ), keyFrames );
 419   animation.Play();
 420
 421   application.SendNotification();
 422   application.Render(500);
 423
 424   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 425   DALI_TEST_EQUALS( actualValue, Color::GREEN, TEST_LOCATION );
 426
 427   application.Render(500);
 428   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 429   DALI_TEST_EQUALS( actualValue, Color::GREEN, TEST_LOCATION );
 430
 431   END_TEST;
 432 }
 433
 434
 435 int UtcDaliRendererUniformMapPrecendence03(void)
 436 {
 437   TestApplication application;
 438
 439   tet_infoline("Test the uniform map precedence is applied properly");
 440
 441   Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
 442   Sampler sampler = Sampler::New(image, "sTexture");
 443   sampler.SetUniformName( "sEffectTexture" );
 444
 445   Shader shader = Shader::New("VertexSource", "FragmentSource");
 446   Material material = Material::New( shader );
 447   material.AddSampler( sampler );
 448   material.SetProperty(Material::Property::COLOR, Color::WHITE);
 449
 450   PropertyBuffer vertexBuffer = CreatePropertyBuffer();
 451   Geometry geometry = CreateQuadGeometryFromBuffer(vertexBuffer);
 452   Renderer renderer = Renderer::New( geometry, material );
 453
 454   Actor actor = Actor::New();
 455   actor.AddRenderer(renderer);
 456   actor.SetSize(400, 400);
 457   Stage::GetCurrent().Add(actor);
 458   application.SendNotification();
 459   application.Render(0);
 460
 461   // Don't add property / uniform map to renderer or actor
 462
 463   material.RegisterProperty( "uFadeColor", Color::BLUE );
 464
 465   sampler.RegisterProperty( "uFadeColor", Color::CYAN );
 466   shader.RegisterProperty( "uFadeColor", Color::MAGENTA );
 467
 468   Property::Index geometryFadeColorIndex = geometry.RegisterProperty( "uFadeColor", Color::YELLOW );
 469
 470   vertexBuffer.RegisterProperty( "uFadeColor", Color::BLACK );
 471
 472
 473   TestGlAbstraction& gl = application.GetGlAbstraction();
 474
 475   application.SendNotification();
 476   application.Render(0);
 477
 478   // Expect that the material's fade color property is accessed
 479   Vector4 actualValue(Vector4::ZERO);
 480   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 481   DALI_TEST_EQUALS( actualValue, Color::BLUE, TEST_LOCATION );
 482
 483   // Animate geometry's fade color property. Should be no change to uniform
 484   Animation  animation = Animation::New(1.0f);
 485   KeyFrames keyFrames = KeyFrames::New();
 486   keyFrames.Add(0.0f, Color::WHITE);
 487   keyFrames.Add(1.0f, Color::TRANSPARENT);
 488   animation.AnimateBetween( Property( geometry, geometryFadeColorIndex ), keyFrames );
 489   animation.Play();
 490
 491   application.SendNotification();
 492   application.Render(500);
 493
 494   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 495   DALI_TEST_EQUALS( actualValue, Color::BLUE, TEST_LOCATION );
 496
 497   application.Render(500);
 498   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 499   DALI_TEST_EQUALS( actualValue, Color::BLUE, TEST_LOCATION );
 500
 501   END_TEST;
 502 }
 503
 504
 505 int UtcDaliRendererUniformMapPrecendence04(void)
 506 {
 507   TestApplication application;
 508
 509   tet_infoline("Test the uniform map precedence is applied properly");
 510
 511   Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
 512   Sampler sampler = Sampler::New(image, "sTexture");
 513   sampler.SetUniformName( "sEffectTexture" );
 514
 515   Shader shader = Shader::New("VertexSource", "FragmentSource");
 516   Material material = Material::New( shader );
 517   material.AddSampler( sampler );
 518   material.SetProperty(Material::Property::COLOR, Color::WHITE);
 519
 520   PropertyBuffer vertexBuffer = CreatePropertyBuffer();
 521   Geometry geometry = CreateQuadGeometryFromBuffer(vertexBuffer);
 522   Renderer renderer = Renderer::New( geometry, material );
 523
 524   Actor actor = Actor::New();
 525   actor.AddRenderer(renderer);
 526   actor.SetSize(400, 400);
 527   Stage::GetCurrent().Add(actor);
 528   application.SendNotification();
 529   application.Render(0);
 530
 531   // Don't add property / uniform map to renderer/actor/material
 532
 533   sampler.RegisterProperty( "uFadeColor", Color::CYAN );
 534   shader.RegisterProperty( "uFadeColor", Color::MAGENTA );
 535
 536   Property::Index geometryFadeColorIndex = geometry.RegisterProperty( "uFadeColor", Color::YELLOW );
 537
 538   vertexBuffer.RegisterProperty( "uFadeColor", Color::BLACK );
 539
 540
 541   TestGlAbstraction& gl = application.GetGlAbstraction();
 542
 543   application.SendNotification();
 544   application.Render(0);
 545
 546   // Expect that the sampler's fade color property is accessed
 547   Vector4 actualValue(Vector4::ZERO);
 548   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 549   DALI_TEST_EQUALS( actualValue, Color::CYAN, TEST_LOCATION );
 550
 551   // Animate geometry's fade color property. Should be no change to uniform
 552   Animation  animation = Animation::New(1.0f);
 553   KeyFrames keyFrames = KeyFrames::New();
 554   keyFrames.Add(0.0f, Color::WHITE);
 555   keyFrames.Add(1.0f, Color::TRANSPARENT);
 556   animation.AnimateBetween( Property( geometry, geometryFadeColorIndex ), keyFrames );
 557   animation.Play();
 558
 559   application.SendNotification();
 560   application.Render(500);
 561
 562   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 563   DALI_TEST_EQUALS( actualValue, Color::CYAN, TEST_LOCATION );
 564
 565   application.Render(500);
 566   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 567   DALI_TEST_EQUALS( actualValue, Color::CYAN, TEST_LOCATION );
 568
 569   END_TEST;
 570 }
 571
 572 int UtcDaliRendererUniformMapPrecendence05(void)
 573 {
 574   TestApplication application;
 575
 576   tet_infoline("Test the uniform map precedence is applied properly");
 577
 578   Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
 579   Sampler sampler = Sampler::New(image, "sTexture");
 580   sampler.SetUniformName( "sEffectTexture" );
 581
 582   Shader shader = Shader::New("VertexSource", "FragmentSource");
 583   Material material = Material::New( shader );
 584   material.AddSampler( sampler );
 585   material.SetProperty(Material::Property::COLOR, Color::WHITE);
 586
 587   PropertyBuffer vertexBuffer = CreatePropertyBuffer();
 588   Geometry geometry = CreateQuadGeometryFromBuffer(vertexBuffer);
 589   Renderer renderer = Renderer::New( geometry, material );
 590
 591   Actor actor = Actor::New();
 592   actor.AddRenderer(renderer);
 593   actor.SetSize(400, 400);
 594   Stage::GetCurrent().Add(actor);
 595   application.SendNotification();
 596   application.Render(0);
 597
 598   // Don't add property / uniform map to renderer/actor/material/sampler
 599
 600   shader.RegisterProperty( "uFadeColor", Color::MAGENTA );
 601
 602   Property::Index geometryFadeColorIndex = geometry.RegisterProperty( "uFadeColor", Color::YELLOW );
 603
 604   vertexBuffer.RegisterProperty( "uFadeColor", Color::BLACK );
 605
 606
 607   TestGlAbstraction& gl = application.GetGlAbstraction();
 608
 609   application.SendNotification();
 610   application.Render(0);
 611
 612   // Expect that the shader's fade color property is accessed
 613   Vector4 actualValue(Vector4::ZERO);
 614   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 615   DALI_TEST_EQUALS( actualValue, Color::MAGENTA, TEST_LOCATION );
 616
 617   // Animate geometry's fade color property. Should be no change to uniform
 618   Animation  animation = Animation::New(1.0f);
 619   KeyFrames keyFrames = KeyFrames::New();
 620   keyFrames.Add(0.0f, Color::WHITE);
 621   keyFrames.Add(1.0f, Color::TRANSPARENT);
 622   animation.AnimateBetween( Property( geometry, geometryFadeColorIndex ), keyFrames );
 623   animation.Play();
 624
 625   application.SendNotification();
 626   application.Render(500);
 627
 628   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 629   DALI_TEST_EQUALS( actualValue, Color::MAGENTA, TEST_LOCATION );
 630
 631   application.Render(500);
 632   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 633   DALI_TEST_EQUALS( actualValue, Color::MAGENTA, TEST_LOCATION );
 634
 635   END_TEST;
 636 }
 637
 638 int UtcDaliRendererUniformMapPrecendence06(void)
 639 {
 640   TestApplication application;
 641
 642   tet_infoline("Test the uniform map precedence is applied properly");
 643
 644   Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
 645   Sampler sampler = Sampler::New(image, "sTexture");
 646   sampler.SetUniformName( "sEffectTexture" );
 647
 648   Shader shader = Shader::New("VertexSource", "FragmentSource");
 649   Material material = Material::New( shader );
 650   material.AddSampler( sampler );
 651   material.SetProperty(Material::Property::COLOR, Color::WHITE);
 652
 653   PropertyBuffer vertexBuffer = CreatePropertyBuffer();
 654   Geometry geometry = CreateQuadGeometryFromBuffer(vertexBuffer);
 655   Renderer renderer = Renderer::New( geometry, material );
 656
 657   Actor actor = Actor::New();
 658   actor.AddRenderer(renderer);
 659   actor.SetSize(400, 400);
 660   Stage::GetCurrent().Add(actor);
 661   application.SendNotification();
 662   application.Render(0);
 663
 664   // Don't add property / uniform map to renderer/actor/material/sampler/shader
 665
 666   geometry.RegisterProperty( "uFadeColor", Color::YELLOW );
 667
 668   Property::Index vertexFadeColorIndex = vertexBuffer.RegisterProperty( "uFadeColor", Color::BLACK );
 669
 670
 671   TestGlAbstraction& gl = application.GetGlAbstraction();
 672
 673   application.SendNotification();
 674   application.Render(0);
 675
 676   // Expect that the geometry's fade color property is accessed
 677   Vector4 actualValue(Vector4::ZERO);
 678   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 679   DALI_TEST_EQUALS( actualValue, Color::YELLOW, TEST_LOCATION );
 680
 681   // Animate vertex buffer's fade color property. Should be no change to uniform
 682   Animation  animation = Animation::New(1.0f);
 683   KeyFrames keyFrames = KeyFrames::New();
 684   keyFrames.Add(0.0f, Color::WHITE);
 685   keyFrames.Add(1.0f, Color::TRANSPARENT);
 686   animation.AnimateBetween( Property( vertexBuffer, vertexFadeColorIndex ), keyFrames );
 687   animation.Play();
 688
 689   application.SendNotification();
 690   application.Render(500);
 691
 692   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 693   DALI_TEST_EQUALS( actualValue, Color::YELLOW, TEST_LOCATION );
 694
 695   application.Render(500);
 696   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 697   DALI_TEST_EQUALS( actualValue, Color::YELLOW, TEST_LOCATION );
 698
 699   END_TEST;
 700 }
 701
 702 int UtcDaliRendererUniformMapPrecendence07(void)
 703 {
 704   TestApplication application;
 705
 706   tet_infoline("Test the uniform map precedence is applied properly");
 707
 708   Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
 709   Sampler sampler = Sampler::New(image, "sTexture");
 710   sampler.SetUniformName( "sEffectTexture" );
 711
 712   Shader shader = Shader::New("VertexSource", "FragmentSource");
 713   Material material = Material::New( shader );
 714   material.AddSampler( sampler );
 715   material.SetProperty(Material::Property::COLOR, Color::WHITE);
 716
 717   PropertyBuffer vertexBuffer = CreatePropertyBuffer();
 718   Geometry geometry = CreateQuadGeometryFromBuffer(vertexBuffer);
 719   Renderer renderer = Renderer::New( geometry, material );
 720
 721   Actor actor = Actor::New();
 722   actor.AddRenderer(renderer);
 723   actor.SetSize(400, 400);
 724   Stage::GetCurrent().Add(actor);
 725   application.SendNotification();
 726   application.Render(0);
 727
 728   // Don't add property / uniform map to renderer/actor/material/sampler/shader/geometry
 729
 730   Property::Index vertexFadeColorIndex = vertexBuffer.RegisterProperty( "uFadeColor", Color::BLACK );
 731
 732   TestGlAbstraction& gl = application.GetGlAbstraction();
 733
 734   application.SendNotification();
 735   application.Render(0);
 736
 737   // Expect that the vertex buffer's fade color property is accessed
 738   Vector4 actualValue(Vector4::ZERO);
 739   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 740   DALI_TEST_EQUALS( actualValue, Color::BLACK, TEST_LOCATION );
 741
 742   // Animate vertex buffer's fade color property. Should change the uniform
 743   Animation  animation = Animation::New(1.0f);
 744   KeyFrames keyFrames = KeyFrames::New();
 745   keyFrames.Add(0.0f, Color::WHITE);
 746   keyFrames.Add(1.0f, Color::TRANSPARENT);
 747   animation.AnimateBetween( Property( vertexBuffer, vertexFadeColorIndex ), keyFrames );
 748   animation.Play();
 749
 750   application.SendNotification();
 751   application.Render(500);
 752
 753   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 754   DALI_TEST_EQUALS( actualValue, Color::WHITE*0.5f, TEST_LOCATION );
 755
 756   application.Render(500);
 757   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 758   DALI_TEST_EQUALS( actualValue, Color::TRANSPARENT, TEST_LOCATION );
 759
 760   END_TEST;
 761 }
 762
 763
 764 int UtcDaliRendererUniformMapMultipleUniforms01(void)
 765 {
 766   TestApplication application;
 767
 768   tet_infoline("Test the uniform maps are collected from all objects (same type)");
 769
 770   Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
 771   Sampler sampler = Sampler::New(image, "sTexture");
 772   sampler.SetUniformName( "sEffectTexture" );
 773
 774   Shader shader = Shader::New("VertexSource", "FragmentSource");
 775   Material material = Material::New( shader );
 776   material.AddSampler( sampler );
 777   material.SetProperty(Material::Property::COLOR, Color::WHITE);
 778
 779   PropertyBuffer vertexBuffer = CreatePropertyBuffer();
 780   Geometry geometry = CreateQuadGeometryFromBuffer(vertexBuffer);
 781   Renderer renderer = Renderer::New( geometry, material );
 782
 783   Actor actor = Actor::New();
 784   actor.AddRenderer(renderer);
 785   actor.SetSize(400, 400);
 786   Stage::GetCurrent().Add(actor);
 787   application.SendNotification();
 788   application.Render(0);
 789
 790   renderer.RegisterProperty( "uUniform1", Color::RED );
 791   actor.RegisterProperty( "uUniform2", Color::GREEN );
 792   material.RegisterProperty( "uUniform3", Color::BLUE );
 793   sampler.RegisterProperty( "uUniform4", Color::CYAN );
 794   shader.RegisterProperty( "uUniform5", Color::MAGENTA );
 795   geometry.RegisterProperty( "uUniform6", Color::YELLOW );
 796   vertexBuffer.RegisterProperty( "uUniform7", Color::BLACK );
 797
 798
 799   TestGlAbstraction& gl = application.GetGlAbstraction();
 800
 801   application.SendNotification();
 802   application.Render(0);
 803
 804   // Expect that each of the object's uniforms are set
 805   Vector4 uniform1Value(Vector4::ZERO);
 806   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uUniform1", uniform1Value ) );
 807   DALI_TEST_EQUALS( uniform1Value, Color::RED, TEST_LOCATION );
 808
 809   Vector4 uniform2Value(Vector4::ZERO);
 810   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uUniform2", uniform2Value ) );
 811   DALI_TEST_EQUALS( uniform2Value, Color::GREEN, TEST_LOCATION );
 812
 813   Vector4 uniform3Value(Vector4::ZERO);
 814   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uUniform3", uniform3Value ) );
 815   DALI_TEST_EQUALS( uniform3Value, Color::BLUE, TEST_LOCATION );
 816
 817   Vector4 uniform4Value(Vector4::ZERO);
 818   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uUniform4", uniform4Value ) );
 819   DALI_TEST_EQUALS( uniform4Value, Color::CYAN, TEST_LOCATION );
 820
 821   Vector4 uniform5Value(Vector4::ZERO);
 822   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uUniform5", uniform5Value ) );
 823   DALI_TEST_EQUALS( uniform5Value, Color::MAGENTA, TEST_LOCATION );
 824
 825   Vector4 uniform6Value(Vector4::ZERO);
 826   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uUniform6", uniform6Value ) );
 827   DALI_TEST_EQUALS( uniform6Value, Color::YELLOW, TEST_LOCATION );
 828
 829   Vector4 uniform7Value(Vector4::ZERO);
 830   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uUniform7", uniform7Value ) );
 831   DALI_TEST_EQUALS( uniform7Value, Color::BLACK, TEST_LOCATION );
 832
 833
 834   END_TEST;
 835 }
 836
 837
 838 int UtcDaliRendererUniformMapMultipleUniforms02(void)
 839 {
 840   TestApplication application;
 841
 842   tet_infoline("Test the uniform maps are collected from all objects (different types)");
 843
 844   Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
 845   Sampler sampler = Sampler::New(image, "sTexture");
 846   sampler.SetUniformName( "sEffectTexture" );
 847
 848   Shader shader = Shader::New("VertexSource", "FragmentSource");
 849   Material material = Material::New( shader );
 850   material.AddSampler( sampler );
 851   material.SetProperty(Material::Property::COLOR, Color::WHITE);
 852
 853   PropertyBuffer vertexBuffer = CreatePropertyBuffer();
 854   Geometry geometry = CreateQuadGeometryFromBuffer(vertexBuffer);
 855   Renderer renderer = Renderer::New( geometry, material );
 856
 857   Actor actor = Actor::New();
 858   actor.AddRenderer(renderer);
 859   actor.SetSize(400, 400);
 860   Stage::GetCurrent().Add(actor);
 861   application.SendNotification();
 862   application.Render(0);
 863
 864   Property::Value value1(Color::RED);
 865   renderer.RegisterProperty( "uFadeColor", value1 );
 866
 867   Property::Value value2(1.0f);
 868   actor.RegisterProperty( "uFadeProgress", value2 );
 869
 870   Property::Value value3(Vector3(0.5f, 0.5f, 1.0f));
 871   material.RegisterProperty( "uFadePosition", value3);
 872
 873   Property::Value value4(Vector2(0.5f, 1.0f));
 874   sampler.RegisterProperty( "uFadeUV", value4 );
 875
 876   Property::Value value5(Matrix3::IDENTITY);
 877   shader.RegisterProperty( "uANormalMatrix", value5 );
 878
 879   Property::Value value6(Matrix::IDENTITY);
 880   geometry.RegisterProperty( "uAWorldMatrix", value6 );
 881
 882   Property::Value value7(7);
 883   vertexBuffer.RegisterProperty( "uAnotherFadeColor", value7 );
 884
 885
 886   TestGlAbstraction& gl = application.GetGlAbstraction();
 887
 888   application.SendNotification();
 889   application.Render(0);
 890
 891   // Expect that each of the object's uniforms are set
 892   Vector4 uniform1Value(Vector4::ZERO);
 893   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", uniform1Value ) );
 894   DALI_TEST_EQUALS( uniform1Value, value1.Get<Vector4>(), TEST_LOCATION );
 895
 896   float uniform2Value(0.0f);
 897   DALI_TEST_CHECK( gl.GetUniformValue<float>( "uFadeProgress", uniform2Value ) );
 898   DALI_TEST_EQUALS( uniform2Value, value2.Get<float>(), TEST_LOCATION );
 899
 900   Vector3 uniform3Value(Vector3::ZERO);
 901   DALI_TEST_CHECK( gl.GetUniformValue<Vector3>( "uFadePosition", uniform3Value ) );
 902   DALI_TEST_EQUALS( uniform3Value, value3.Get<Vector3>(), TEST_LOCATION );
 903
 904   Vector2 uniform4Value(Vector2::ZERO);
 905   DALI_TEST_CHECK( gl.GetUniformValue<Vector2>( "uFadeUV", uniform4Value ) );
 906   DALI_TEST_EQUALS( uniform4Value, value4.Get<Vector2>(), TEST_LOCATION );
 907
 908   Matrix3 uniform5Value;
 909   DALI_TEST_CHECK( gl.GetUniformValue<Matrix3>( "uANormalMatrix", uniform5Value ) );
 910   DALI_TEST_EQUALS( uniform5Value, value5.Get<Matrix3>(), TEST_LOCATION );
 911
 912   Matrix uniform6Value;
 913   DALI_TEST_CHECK( gl.GetUniformValue<Matrix>( "uAWorldMatrix", uniform6Value ) );
 914   DALI_TEST_EQUALS( uniform6Value, value6.Get<Matrix>(), TEST_LOCATION );
 915
 916   int uniform7Value = 0;
 917   DALI_TEST_CHECK( gl.GetUniformValue<int>( "uAnotherFadeColor", uniform7Value ) );
 918   DALI_TEST_EQUALS( uniform7Value, value7.Get<int>(), TEST_LOCATION );
 919
 920   END_TEST;
 921 }