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( "fade-color", 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( "fade-color", initialColor );
 156   renderer.AddUniformMapping( colorIndex, std::string("uFadeColor") );
 157
 158   TestGlAbstraction& gl = application.GetGlAbstraction();
 159
 160   application.SendNotification();
 161   application.Render(0);
 162
 163   Vector4 actualValue(Vector4::ZERO);
 164   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 165   DALI_TEST_EQUALS( actualValue, initialColor, TEST_LOCATION );
 166
 167   // Apply constraint
 168   Constraint constraint = Constraint::New<Vector4>( renderer, colorIndex, TestConstraintNoBlue );
 169   constraint.Apply();
 170   application.SendNotification();
 171   application.Render(0);
 172
 173    // Expect no blue component in either buffer - yellow
 174   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 175   DALI_TEST_EQUALS( actualValue, Color::YELLOW, TEST_LOCATION );
 176
 177   application.Render(0);
 178   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 179   DALI_TEST_EQUALS( actualValue, Color::YELLOW, TEST_LOCATION );
 180
 181   renderer.RemoveConstraints();
 182   renderer.SetProperty(colorIndex, Color::WHITE );
 183   application.SendNotification();
 184   application.Render(0);
 185
 186   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 187   DALI_TEST_EQUALS( actualValue, Color::WHITE, TEST_LOCATION );
 188
 189   END_TEST;
 190 }
 191
 192
 193
 194 int UtcDaliRendererAnimatedProperty01(void)
 195 {
 196   TestApplication application;
 197
 198   tet_infoline("Test that a non-uniform renderer property can be animated");
 199
 200   Shader shader = Shader::New("VertexSource", "FragmentSource");
 201   Material material = Material::New( shader );
 202   material.SetProperty(Material::Property::COLOR, Color::WHITE);
 203
 204   Geometry geometry = CreateQuadGeometry();
 205   Renderer renderer = Renderer::New( geometry, material );
 206
 207   Actor actor = Actor::New();
 208   actor.AddRenderer(renderer);
 209   actor.SetSize(400, 400);
 210   Stage::GetCurrent().Add(actor);
 211
 212   Vector4 initialColor = Color::WHITE;
 213   Property::Index colorIndex = renderer.RegisterProperty( "fade-color", initialColor );
 214
 215   application.SendNotification();
 216   application.Render(0);
 217   DALI_TEST_EQUALS( renderer.GetProperty<Vector4>(colorIndex), initialColor, TEST_LOCATION );
 218
 219   Animation  animation = Animation::New(1.0f);
 220   KeyFrames keyFrames = KeyFrames::New();
 221   keyFrames.Add(0.0f, initialColor);
 222   keyFrames.Add(1.0f, Color::TRANSPARENT);
 223   animation.AnimateBetween( Property( renderer, colorIndex ), keyFrames );
 224   animation.Play();
 225
 226   application.SendNotification();
 227   application.Render(500);
 228
 229   DALI_TEST_EQUALS( renderer.GetProperty<Vector4>(colorIndex), Color::WHITE * 0.5f, TEST_LOCATION );
 230
 231   application.Render(500);
 232
 233   DALI_TEST_EQUALS( renderer.GetProperty<Vector4>(colorIndex), Color::TRANSPARENT, TEST_LOCATION );
 234
 235   END_TEST;
 236 }
 237
 238 int UtcDaliRendererAnimatedProperty02(void)
 239 {
 240   TestApplication application;
 241
 242   tet_infoline("Test that a uniform map renderer property can be animated");
 243
 244   Shader shader = Shader::New("VertexSource", "FragmentSource");
 245   Material material = Material::New( shader );
 246   material.SetProperty(Material::Property::COLOR, Color::WHITE);
 247
 248   Geometry geometry = CreateQuadGeometry();
 249   Renderer renderer = Renderer::New( geometry, material );
 250
 251   Actor actor = Actor::New();
 252   actor.AddRenderer(renderer);
 253   actor.SetSize(400, 400);
 254   Stage::GetCurrent().Add(actor);
 255   application.SendNotification();
 256   application.Render(0);
 257
 258   Vector4 initialColor = Color::WHITE;
 259   Property::Index colorIndex = renderer.RegisterProperty( "fade-color", initialColor );
 260   renderer.AddUniformMapping( colorIndex, std::string("uFadeColor") );
 261
 262   TestGlAbstraction& gl = application.GetGlAbstraction();
 263
 264   application.SendNotification();
 265   application.Render(0);
 266
 267   Vector4 actualValue(Vector4::ZERO);
 268   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 269   DALI_TEST_EQUALS( actualValue, initialColor, TEST_LOCATION );
 270
 271   Animation  animation = Animation::New(1.0f);
 272   KeyFrames keyFrames = KeyFrames::New();
 273   keyFrames.Add(0.0f, initialColor);
 274   keyFrames.Add(1.0f, Color::TRANSPARENT);
 275   animation.AnimateBetween( Property( renderer, colorIndex ), keyFrames );
 276   animation.Play();
 277
 278   application.SendNotification();
 279   application.Render(500);
 280
 281   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 282   DALI_TEST_EQUALS( actualValue, Color::WHITE * 0.5f, TEST_LOCATION );
 283
 284   application.Render(500);
 285   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 286   DALI_TEST_EQUALS( actualValue, Color::TRANSPARENT, TEST_LOCATION );
 287
 288   END_TEST;
 289 }
 290
 291
 292
 293
 294 int UtcDaliRendererUniformMapPrecendence01(void)
 295 {
 296   TestApplication application;
 297
 298   tet_infoline("Test the uniform map precedence is applied properly");
 299
 300   Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
 301   Sampler sampler = Sampler::New(image, "sTexture");
 302   sampler.SetUniformName( "sEffectTexture" );
 303
 304   Shader shader = Shader::New("VertexSource", "FragmentSource");
 305   Material material = Material::New( shader );
 306   material.AddSampler( sampler );
 307   material.SetProperty(Material::Property::COLOR, Color::WHITE);
 308
 309   PropertyBuffer vertexBuffer = CreatePropertyBuffer();
 310   Geometry geometry = CreateQuadGeometryFromBuffer(vertexBuffer);
 311   Renderer renderer = Renderer::New( geometry, material );
 312
 313   Actor actor = Actor::New();
 314   actor.AddRenderer(renderer);
 315   actor.SetSize(400, 400);
 316   Stage::GetCurrent().Add(actor);
 317   application.SendNotification();
 318   application.Render(0);
 319
 320   Property::Index rendererFadeColorIndex = renderer.RegisterProperty( "fade-color-a", Color::RED );
 321   renderer.AddUniformMapping( rendererFadeColorIndex, std::string("uFadeColor") );
 322
 323   Property::Index actorFadeColorIndex = actor.RegisterProperty( "fade-color-b", Color::GREEN );
 324   actor.AddUniformMapping( actorFadeColorIndex, std::string("uFadeColor") );
 325
 326   Property::Index materialFadeColorIndex = material.RegisterProperty( "fade-color-c", Color::BLUE );
 327   material.AddUniformMapping( materialFadeColorIndex, std::string("uFadeColor") );
 328
 329   Property::Index samplerFadeColorIndex = sampler.RegisterProperty( "fade-color-d", Color::CYAN );
 330   sampler.AddUniformMapping( samplerFadeColorIndex, std::string("uFadeColor") );
 331   Property::Index shaderFadeColorIndex = shader.RegisterProperty( "fade-color-e", Color::MAGENTA );
 332   shader.AddUniformMapping( shaderFadeColorIndex, std::string("uFadeColor") );
 333
 334   Property::Index geometryFadeColorIndex = geometry.RegisterProperty( "fade-color-f", Color::YELLOW );
 335   geometry.AddUniformMapping( geometryFadeColorIndex, std::string("uFadeColor") );
 336
 337   Property::Index vertexFadeColorIndex = vertexBuffer.RegisterProperty( "fade-color-g", Color::BLACK );
 338   vertexBuffer.AddUniformMapping( vertexFadeColorIndex, std::string("uFadeColor") );
 339
 340
 341   TestGlAbstraction& gl = application.GetGlAbstraction();
 342
 343   application.SendNotification();
 344   application.Render(0);
 345
 346   // Expect that the renderer's fade color property is accessed
 347   Vector4 actualValue(Vector4::ZERO);
 348   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 349   DALI_TEST_EQUALS( actualValue, Color::RED, TEST_LOCATION );
 350
 351   // Animate material's fade color property. Should be no change to uniform
 352   Animation  animation = Animation::New(1.0f);
 353   KeyFrames keyFrames = KeyFrames::New();
 354   keyFrames.Add(0.0f, Color::WHITE);
 355   keyFrames.Add(1.0f, Color::TRANSPARENT);
 356   animation.AnimateBetween( Property( material, materialFadeColorIndex ), keyFrames );
 357   animation.Play();
 358
 359   application.SendNotification();
 360   application.Render(500);
 361
 362   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 363   DALI_TEST_EQUALS( actualValue, Color::RED, TEST_LOCATION );
 364
 365   application.Render(500);
 366   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 367   DALI_TEST_EQUALS( actualValue, Color::RED, TEST_LOCATION );
 368
 369   END_TEST;
 370 }
 371
 372 int UtcDaliRendererUniformMapPrecendence02(void)
 373 {
 374   TestApplication application;
 375
 376   tet_infoline("Test the uniform map precedence is applied properly");
 377
 378   Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
 379   Sampler sampler = Sampler::New(image, "sTexture");
 380   sampler.SetUniformName( "sEffectTexture" );
 381
 382   Shader shader = Shader::New("VertexSource", "FragmentSource");
 383   Material material = Material::New( shader );
 384   material.AddSampler( sampler );
 385   material.SetProperty(Material::Property::COLOR, Color::WHITE);
 386
 387   PropertyBuffer vertexBuffer = CreatePropertyBuffer();
 388   Geometry geometry = CreateQuadGeometryFromBuffer(vertexBuffer);
 389   Renderer renderer = Renderer::New( geometry, material );
 390
 391   Actor actor = Actor::New();
 392   actor.AddRenderer(renderer);
 393   actor.SetSize(400, 400);
 394   Stage::GetCurrent().Add(actor);
 395   application.SendNotification();
 396   application.Render(0);
 397
 398   // Don't add property / uniform map to renderer
 399
 400   Property::Index actorFadeColorIndex = actor.RegisterProperty( "fade-color-b", Color::GREEN );
 401   actor.AddUniformMapping( actorFadeColorIndex, std::string("uFadeColor") );
 402
 403   Property::Index materialFadeColorIndex = material.RegisterProperty( "fade-color-c", Color::BLUE );
 404   material.AddUniformMapping( materialFadeColorIndex, std::string("uFadeColor") );
 405
 406   Property::Index samplerFadeColorIndex = sampler.RegisterProperty( "fade-color-d", Color::CYAN );
 407   sampler.AddUniformMapping( samplerFadeColorIndex, std::string("uFadeColor") );
 408   Property::Index shaderFadeColorIndex = shader.RegisterProperty( "fade-color-e", Color::MAGENTA );
 409   shader.AddUniformMapping( shaderFadeColorIndex, std::string("uFadeColor") );
 410
 411   Property::Index geometryFadeColorIndex = geometry.RegisterProperty( "fade-color-f", Color::YELLOW );
 412   geometry.AddUniformMapping( geometryFadeColorIndex, std::string("uFadeColor") );
 413
 414   Property::Index vertexFadeColorIndex = vertexBuffer.RegisterProperty( "fade-color-g", Color::BLACK );
 415   vertexBuffer.AddUniformMapping( vertexFadeColorIndex, std::string("uFadeColor") );
 416
 417
 418   TestGlAbstraction& gl = application.GetGlAbstraction();
 419
 420   application.SendNotification();
 421   application.Render(0);
 422
 423   // Expect that the actor's fade color property is accessed
 424   Vector4 actualValue(Vector4::ZERO);
 425   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 426   DALI_TEST_EQUALS( actualValue, Color::GREEN, TEST_LOCATION );
 427
 428   // Animate material's fade color property. Should be no change to uniform
 429   Animation  animation = Animation::New(1.0f);
 430   KeyFrames keyFrames = KeyFrames::New();
 431   keyFrames.Add(0.0f, Color::WHITE);
 432   keyFrames.Add(1.0f, Color::TRANSPARENT);
 433   animation.AnimateBetween( Property( material, materialFadeColorIndex ), keyFrames );
 434   animation.Play();
 435
 436   application.SendNotification();
 437   application.Render(500);
 438
 439   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 440   DALI_TEST_EQUALS( actualValue, Color::GREEN, TEST_LOCATION );
 441
 442   application.Render(500);
 443   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 444   DALI_TEST_EQUALS( actualValue, Color::GREEN, TEST_LOCATION );
 445
 446   END_TEST;
 447 }
 448
 449
 450 int UtcDaliRendererUniformMapPrecendence03(void)
 451 {
 452   TestApplication application;
 453
 454   tet_infoline("Test the uniform map precedence is applied properly");
 455
 456   Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
 457   Sampler sampler = Sampler::New(image, "sTexture");
 458   sampler.SetUniformName( "sEffectTexture" );
 459
 460   Shader shader = Shader::New("VertexSource", "FragmentSource");
 461   Material material = Material::New( shader );
 462   material.AddSampler( sampler );
 463   material.SetProperty(Material::Property::COLOR, Color::WHITE);
 464
 465   PropertyBuffer vertexBuffer = CreatePropertyBuffer();
 466   Geometry geometry = CreateQuadGeometryFromBuffer(vertexBuffer);
 467   Renderer renderer = Renderer::New( geometry, material );
 468
 469   Actor actor = Actor::New();
 470   actor.AddRenderer(renderer);
 471   actor.SetSize(400, 400);
 472   Stage::GetCurrent().Add(actor);
 473   application.SendNotification();
 474   application.Render(0);
 475
 476   // Don't add property / uniform map to renderer or actor
 477
 478   Property::Index materialFadeColorIndex = material.RegisterProperty( "fade-color-c", Color::BLUE );
 479   material.AddUniformMapping( materialFadeColorIndex, std::string("uFadeColor") );
 480
 481   Property::Index samplerFadeColorIndex = sampler.RegisterProperty( "fade-color-d", Color::CYAN );
 482   sampler.AddUniformMapping( samplerFadeColorIndex, std::string("uFadeColor") );
 483   Property::Index shaderFadeColorIndex = shader.RegisterProperty( "fade-color-e", Color::MAGENTA );
 484   shader.AddUniformMapping( shaderFadeColorIndex, std::string("uFadeColor") );
 485
 486   Property::Index geometryFadeColorIndex = geometry.RegisterProperty( "fade-color-f", Color::YELLOW );
 487   geometry.AddUniformMapping( geometryFadeColorIndex, std::string("uFadeColor") );
 488
 489   Property::Index vertexFadeColorIndex = vertexBuffer.RegisterProperty( "fade-color-g", Color::BLACK );
 490   vertexBuffer.AddUniformMapping( vertexFadeColorIndex, std::string("uFadeColor") );
 491
 492
 493   TestGlAbstraction& gl = application.GetGlAbstraction();
 494
 495   application.SendNotification();
 496   application.Render(0);
 497
 498   // Expect that the material's fade color property is accessed
 499   Vector4 actualValue(Vector4::ZERO);
 500   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 501   DALI_TEST_EQUALS( actualValue, Color::BLUE, TEST_LOCATION );
 502
 503   // Animate geometry's fade color property. Should be no change to uniform
 504   Animation  animation = Animation::New(1.0f);
 505   KeyFrames keyFrames = KeyFrames::New();
 506   keyFrames.Add(0.0f, Color::WHITE);
 507   keyFrames.Add(1.0f, Color::TRANSPARENT);
 508   animation.AnimateBetween( Property( geometry, geometryFadeColorIndex ), keyFrames );
 509   animation.Play();
 510
 511   application.SendNotification();
 512   application.Render(500);
 513
 514   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 515   DALI_TEST_EQUALS( actualValue, Color::BLUE, TEST_LOCATION );
 516
 517   application.Render(500);
 518   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 519   DALI_TEST_EQUALS( actualValue, Color::BLUE, TEST_LOCATION );
 520
 521   END_TEST;
 522 }
 523
 524
 525 int UtcDaliRendererUniformMapPrecendence04(void)
 526 {
 527   TestApplication application;
 528
 529   tet_infoline("Test the uniform map precedence is applied properly");
 530
 531   Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
 532   Sampler sampler = Sampler::New(image, "sTexture");
 533   sampler.SetUniformName( "sEffectTexture" );
 534
 535   Shader shader = Shader::New("VertexSource", "FragmentSource");
 536   Material material = Material::New( shader );
 537   material.AddSampler( sampler );
 538   material.SetProperty(Material::Property::COLOR, Color::WHITE);
 539
 540   PropertyBuffer vertexBuffer = CreatePropertyBuffer();
 541   Geometry geometry = CreateQuadGeometryFromBuffer(vertexBuffer);
 542   Renderer renderer = Renderer::New( geometry, material );
 543
 544   Actor actor = Actor::New();
 545   actor.AddRenderer(renderer);
 546   actor.SetSize(400, 400);
 547   Stage::GetCurrent().Add(actor);
 548   application.SendNotification();
 549   application.Render(0);
 550
 551   // Don't add property / uniform map to renderer/actor/material
 552
 553   Property::Index samplerFadeColorIndex = sampler.RegisterProperty( "fade-color-d", Color::CYAN );
 554   sampler.AddUniformMapping( samplerFadeColorIndex, std::string("uFadeColor") );
 555   Property::Index shaderFadeColorIndex = shader.RegisterProperty( "fade-color-e", Color::MAGENTA );
 556   shader.AddUniformMapping( shaderFadeColorIndex, std::string("uFadeColor") );
 557
 558   Property::Index geometryFadeColorIndex = geometry.RegisterProperty( "fade-color-f", Color::YELLOW );
 559   geometry.AddUniformMapping( geometryFadeColorIndex, std::string("uFadeColor") );
 560
 561   Property::Index vertexFadeColorIndex = vertexBuffer.RegisterProperty( "fade-color-g", Color::BLACK );
 562   vertexBuffer.AddUniformMapping( vertexFadeColorIndex, std::string("uFadeColor") );
 563
 564
 565   TestGlAbstraction& gl = application.GetGlAbstraction();
 566
 567   application.SendNotification();
 568   application.Render(0);
 569
 570   // Expect that the sampler's fade color property is accessed
 571   Vector4 actualValue(Vector4::ZERO);
 572   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 573   DALI_TEST_EQUALS( actualValue, Color::CYAN, TEST_LOCATION );
 574
 575   // Animate geometry's fade color property. Should be no change to uniform
 576   Animation  animation = Animation::New(1.0f);
 577   KeyFrames keyFrames = KeyFrames::New();
 578   keyFrames.Add(0.0f, Color::WHITE);
 579   keyFrames.Add(1.0f, Color::TRANSPARENT);
 580   animation.AnimateBetween( Property( geometry, geometryFadeColorIndex ), keyFrames );
 581   animation.Play();
 582
 583   application.SendNotification();
 584   application.Render(500);
 585
 586   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 587   DALI_TEST_EQUALS( actualValue, Color::CYAN, TEST_LOCATION );
 588
 589   application.Render(500);
 590   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 591   DALI_TEST_EQUALS( actualValue, Color::CYAN, TEST_LOCATION );
 592
 593   END_TEST;
 594 }
 595
 596 int UtcDaliRendererUniformMapPrecendence05(void)
 597 {
 598   TestApplication application;
 599
 600   tet_infoline("Test the uniform map precedence is applied properly");
 601
 602   Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
 603   Sampler sampler = Sampler::New(image, "sTexture");
 604   sampler.SetUniformName( "sEffectTexture" );
 605
 606   Shader shader = Shader::New("VertexSource", "FragmentSource");
 607   Material material = Material::New( shader );
 608   material.AddSampler( sampler );
 609   material.SetProperty(Material::Property::COLOR, Color::WHITE);
 610
 611   PropertyBuffer vertexBuffer = CreatePropertyBuffer();
 612   Geometry geometry = CreateQuadGeometryFromBuffer(vertexBuffer);
 613   Renderer renderer = Renderer::New( geometry, material );
 614
 615   Actor actor = Actor::New();
 616   actor.AddRenderer(renderer);
 617   actor.SetSize(400, 400);
 618   Stage::GetCurrent().Add(actor);
 619   application.SendNotification();
 620   application.Render(0);
 621
 622   // Don't add property / uniform map to renderer/actor/material/sampler
 623
 624   Property::Index shaderFadeColorIndex = shader.RegisterProperty( "fade-color-e", Color::MAGENTA );
 625   shader.AddUniformMapping( shaderFadeColorIndex, std::string("uFadeColor") );
 626
 627   Property::Index geometryFadeColorIndex = geometry.RegisterProperty( "fade-color-f", Color::YELLOW );
 628   geometry.AddUniformMapping( geometryFadeColorIndex, std::string("uFadeColor") );
 629
 630   Property::Index vertexFadeColorIndex = vertexBuffer.RegisterProperty( "fade-color-g", Color::BLACK );
 631   vertexBuffer.AddUniformMapping( vertexFadeColorIndex, std::string("uFadeColor") );
 632
 633
 634   TestGlAbstraction& gl = application.GetGlAbstraction();
 635
 636   application.SendNotification();
 637   application.Render(0);
 638
 639   // Expect that the shader's fade color property is accessed
 640   Vector4 actualValue(Vector4::ZERO);
 641   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 642   DALI_TEST_EQUALS( actualValue, Color::MAGENTA, TEST_LOCATION );
 643
 644   // Animate geometry's fade color property. Should be no change to uniform
 645   Animation  animation = Animation::New(1.0f);
 646   KeyFrames keyFrames = KeyFrames::New();
 647   keyFrames.Add(0.0f, Color::WHITE);
 648   keyFrames.Add(1.0f, Color::TRANSPARENT);
 649   animation.AnimateBetween( Property( geometry, geometryFadeColorIndex ), keyFrames );
 650   animation.Play();
 651
 652   application.SendNotification();
 653   application.Render(500);
 654
 655   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 656   DALI_TEST_EQUALS( actualValue, Color::MAGENTA, TEST_LOCATION );
 657
 658   application.Render(500);
 659   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 660   DALI_TEST_EQUALS( actualValue, Color::MAGENTA, TEST_LOCATION );
 661
 662   END_TEST;
 663 }
 664
 665 int UtcDaliRendererUniformMapPrecendence06(void)
 666 {
 667   TestApplication application;
 668
 669   tet_infoline("Test the uniform map precedence is applied properly");
 670
 671   Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
 672   Sampler sampler = Sampler::New(image, "sTexture");
 673   sampler.SetUniformName( "sEffectTexture" );
 674
 675   Shader shader = Shader::New("VertexSource", "FragmentSource");
 676   Material material = Material::New( shader );
 677   material.AddSampler( sampler );
 678   material.SetProperty(Material::Property::COLOR, Color::WHITE);
 679
 680   PropertyBuffer vertexBuffer = CreatePropertyBuffer();
 681   Geometry geometry = CreateQuadGeometryFromBuffer(vertexBuffer);
 682   Renderer renderer = Renderer::New( geometry, material );
 683
 684   Actor actor = Actor::New();
 685   actor.AddRenderer(renderer);
 686   actor.SetSize(400, 400);
 687   Stage::GetCurrent().Add(actor);
 688   application.SendNotification();
 689   application.Render(0);
 690
 691   // Don't add property / uniform map to renderer/actor/material/sampler/shader
 692
 693   Property::Index geometryFadeColorIndex = geometry.RegisterProperty( "fade-color-f", Color::YELLOW );
 694   geometry.AddUniformMapping( geometryFadeColorIndex, std::string("uFadeColor") );
 695
 696   Property::Index vertexFadeColorIndex = vertexBuffer.RegisterProperty( "fade-color-g", Color::BLACK );
 697   vertexBuffer.AddUniformMapping( vertexFadeColorIndex, std::string("uFadeColor") );
 698
 699
 700   TestGlAbstraction& gl = application.GetGlAbstraction();
 701
 702   application.SendNotification();
 703   application.Render(0);
 704
 705   // Expect that the geometry's fade color property is accessed
 706   Vector4 actualValue(Vector4::ZERO);
 707   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 708   DALI_TEST_EQUALS( actualValue, Color::YELLOW, TEST_LOCATION );
 709
 710   // Animate vertex buffer's fade color property. Should be no change to uniform
 711   Animation  animation = Animation::New(1.0f);
 712   KeyFrames keyFrames = KeyFrames::New();
 713   keyFrames.Add(0.0f, Color::WHITE);
 714   keyFrames.Add(1.0f, Color::TRANSPARENT);
 715   animation.AnimateBetween( Property( vertexBuffer, vertexFadeColorIndex ), keyFrames );
 716   animation.Play();
 717
 718   application.SendNotification();
 719   application.Render(500);
 720
 721   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 722   DALI_TEST_EQUALS( actualValue, Color::YELLOW, TEST_LOCATION );
 723
 724   application.Render(500);
 725   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 726   DALI_TEST_EQUALS( actualValue, Color::YELLOW, TEST_LOCATION );
 727
 728   END_TEST;
 729 }
 730
 731 int UtcDaliRendererUniformMapPrecendence07(void)
 732 {
 733   TestApplication application;
 734
 735   tet_infoline("Test the uniform map precedence is applied properly");
 736
 737   Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
 738   Sampler sampler = Sampler::New(image, "sTexture");
 739   sampler.SetUniformName( "sEffectTexture" );
 740
 741   Shader shader = Shader::New("VertexSource", "FragmentSource");
 742   Material material = Material::New( shader );
 743   material.AddSampler( sampler );
 744   material.SetProperty(Material::Property::COLOR, Color::WHITE);
 745
 746   PropertyBuffer vertexBuffer = CreatePropertyBuffer();
 747   Geometry geometry = CreateQuadGeometryFromBuffer(vertexBuffer);
 748   Renderer renderer = Renderer::New( geometry, material );
 749
 750   Actor actor = Actor::New();
 751   actor.AddRenderer(renderer);
 752   actor.SetSize(400, 400);
 753   Stage::GetCurrent().Add(actor);
 754   application.SendNotification();
 755   application.Render(0);
 756
 757   // Don't add property / uniform map to renderer/actor/material/sampler/shader/geometry
 758
 759   Property::Index vertexFadeColorIndex = vertexBuffer.RegisterProperty( "fade-color-g", Color::BLACK );
 760   vertexBuffer.AddUniformMapping( vertexFadeColorIndex, std::string("uFadeColor") );
 761
 762   TestGlAbstraction& gl = application.GetGlAbstraction();
 763
 764   application.SendNotification();
 765   application.Render(0);
 766
 767   // Expect that the vertex buffer's fade color property is accessed
 768   Vector4 actualValue(Vector4::ZERO);
 769   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 770   DALI_TEST_EQUALS( actualValue, Color::BLACK, TEST_LOCATION );
 771
 772   // Animate vertex buffer's fade color property. Should change the uniform
 773   Animation  animation = Animation::New(1.0f);
 774   KeyFrames keyFrames = KeyFrames::New();
 775   keyFrames.Add(0.0f, Color::WHITE);
 776   keyFrames.Add(1.0f, Color::TRANSPARENT);
 777   animation.AnimateBetween( Property( vertexBuffer, vertexFadeColorIndex ), keyFrames );
 778   animation.Play();
 779
 780   application.SendNotification();
 781   application.Render(500);
 782
 783   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 784   DALI_TEST_EQUALS( actualValue, Color::WHITE*0.5f, TEST_LOCATION );
 785
 786   application.Render(500);
 787   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
 788   DALI_TEST_EQUALS( actualValue, Color::TRANSPARENT, TEST_LOCATION );
 789
 790   END_TEST;
 791 }
 792
 793
 794 int UtcDaliRendererUniformMapMultipleUniforms01(void)
 795 {
 796   TestApplication application;
 797
 798   tet_infoline("Test the uniform maps are collected from all objects (same type)");
 799
 800   Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
 801   Sampler sampler = Sampler::New(image, "sTexture");
 802   sampler.SetUniformName( "sEffectTexture" );
 803
 804   Shader shader = Shader::New("VertexSource", "FragmentSource");
 805   Material material = Material::New( shader );
 806   material.AddSampler( sampler );
 807   material.SetProperty(Material::Property::COLOR, Color::WHITE);
 808
 809   PropertyBuffer vertexBuffer = CreatePropertyBuffer();
 810   Geometry geometry = CreateQuadGeometryFromBuffer(vertexBuffer);
 811   Renderer renderer = Renderer::New( geometry, material );
 812
 813   Actor actor = Actor::New();
 814   actor.AddRenderer(renderer);
 815   actor.SetSize(400, 400);
 816   Stage::GetCurrent().Add(actor);
 817   application.SendNotification();
 818   application.Render(0);
 819
 820   Property::Index rendererFadeColorIndex = renderer.RegisterProperty( "fade-color", Color::RED );
 821   renderer.AddUniformMapping( rendererFadeColorIndex, std::string("uUniform1") );
 822
 823   Property::Index actorFadeColorIndex = actor.RegisterProperty( "fade-color", Color::GREEN );
 824   actor.AddUniformMapping( actorFadeColorIndex, std::string("uUniform2") );
 825
 826   Property::Index materialFadeColorIndex = material.RegisterProperty( "fade-color", Color::BLUE );
 827   material.AddUniformMapping( materialFadeColorIndex, std::string("uUniform3") );
 828
 829   Property::Index samplerFadeColorIndex = sampler.RegisterProperty( "fade-color", Color::CYAN );
 830   sampler.AddUniformMapping( samplerFadeColorIndex, std::string("uUniform4") );
 831   Property::Index shaderFadeColorIndex = shader.RegisterProperty( "fade-color", Color::MAGENTA );
 832   shader.AddUniformMapping( shaderFadeColorIndex, std::string("uUniform5") );
 833
 834   Property::Index geometryFadeColorIndex = geometry.RegisterProperty( "fade-color", Color::YELLOW );
 835   geometry.AddUniformMapping( geometryFadeColorIndex, std::string("uUniform6") );
 836
 837   Property::Index vertexFadeColorIndex = vertexBuffer.RegisterProperty( "fade-color", Color::BLACK );
 838   vertexBuffer.AddUniformMapping( vertexFadeColorIndex, std::string("uUniform7") );
 839
 840
 841   TestGlAbstraction& gl = application.GetGlAbstraction();
 842
 843   application.SendNotification();
 844   application.Render(0);
 845
 846   // Expect that each of the object's uniforms are set
 847   Vector4 uniform1Value(Vector4::ZERO);
 848   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uUniform1", uniform1Value ) );
 849   DALI_TEST_EQUALS( uniform1Value, Color::RED, TEST_LOCATION );
 850
 851   Vector4 uniform2Value(Vector4::ZERO);
 852   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uUniform2", uniform2Value ) );
 853   DALI_TEST_EQUALS( uniform2Value, Color::GREEN, TEST_LOCATION );
 854
 855   Vector4 uniform3Value(Vector4::ZERO);
 856   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uUniform3", uniform3Value ) );
 857   DALI_TEST_EQUALS( uniform3Value, Color::BLUE, TEST_LOCATION );
 858
 859   Vector4 uniform4Value(Vector4::ZERO);
 860   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uUniform4", uniform4Value ) );
 861   DALI_TEST_EQUALS( uniform4Value, Color::CYAN, TEST_LOCATION );
 862
 863   Vector4 uniform5Value(Vector4::ZERO);
 864   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uUniform5", uniform5Value ) );
 865   DALI_TEST_EQUALS( uniform5Value, Color::MAGENTA, TEST_LOCATION );
 866
 867   Vector4 uniform6Value(Vector4::ZERO);
 868   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uUniform6", uniform6Value ) );
 869   DALI_TEST_EQUALS( uniform6Value, Color::YELLOW, TEST_LOCATION );
 870
 871   Vector4 uniform7Value(Vector4::ZERO);
 872   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uUniform7", uniform7Value ) );
 873   DALI_TEST_EQUALS( uniform7Value, Color::BLACK, TEST_LOCATION );
 874
 875
 876   END_TEST;
 877 }
 878
 879
 880 int UtcDaliRendererUniformMapMultipleUniforms02(void)
 881 {
 882   TestApplication application;
 883
 884   tet_infoline("Test the uniform maps are collected from all objects (different types)");
 885
 886   Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
 887   Sampler sampler = Sampler::New(image, "sTexture");
 888   sampler.SetUniformName( "sEffectTexture" );
 889
 890   Shader shader = Shader::New("VertexSource", "FragmentSource");
 891   Material material = Material::New( shader );
 892   material.AddSampler( sampler );
 893   material.SetProperty(Material::Property::COLOR, Color::WHITE);
 894
 895   PropertyBuffer vertexBuffer = CreatePropertyBuffer();
 896   Geometry geometry = CreateQuadGeometryFromBuffer(vertexBuffer);
 897   Renderer renderer = Renderer::New( geometry, material );
 898
 899   Actor actor = Actor::New();
 900   actor.AddRenderer(renderer);
 901   actor.SetSize(400, 400);
 902   Stage::GetCurrent().Add(actor);
 903   application.SendNotification();
 904   application.Render(0);
 905
 906   Property::Value value1(Color::RED);
 907   Property::Index rendererIndex = renderer.RegisterProperty( "fade-color", value1 );
 908   renderer.AddUniformMapping( rendererIndex, std::string("uUniform1") );
 909
 910   Property::Value value2(1.0f);
 911   Property::Index actorIndex = actor.RegisterProperty( "fade-progress", value2 );
 912   actor.AddUniformMapping( actorIndex, std::string("uUniform2") );
 913
 914   Property::Value value3(Vector3(0.5f, 0.5f, 1.0f));
 915   Property::Index materialIndex = material.RegisterProperty( "fade-position", value3);
 916   material.AddUniformMapping( materialIndex, std::string("uUniform3") );
 917
 918   Property::Value value4(Vector2(0.5f, 1.0f));
 919   Property::Index samplerIndex = sampler.RegisterProperty( "fade-uv", value4 );
 920   sampler.AddUniformMapping( samplerIndex, std::string("uUniform4") );
 921
 922   Property::Value value5(Matrix3::IDENTITY);
 923   Property::Index shaderIndex = shader.RegisterProperty( "a-normal-matrix", value5 );
 924   shader.AddUniformMapping( shaderIndex, std::string("uUniform5") );
 925
 926   Property::Value value6(Matrix::IDENTITY);
 927   Property::Index geometryIndex = geometry.RegisterProperty( "a-world-matrix", value6 );
 928   geometry.AddUniformMapping( geometryIndex, std::string("uUniform6") );
 929
 930   Property::Value value7(7);
 931   Property::Index vertexIndex = vertexBuffer.RegisterProperty( "fade-color", value7 );
 932   vertexBuffer.AddUniformMapping( vertexIndex, std::string("uUniform7") );
 933
 934
 935   TestGlAbstraction& gl = application.GetGlAbstraction();
 936
 937   application.SendNotification();
 938   application.Render(0);
 939
 940   // Expect that each of the object's uniforms are set
 941   Vector4 uniform1Value(Vector4::ZERO);
 942   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uUniform1", uniform1Value ) );
 943   DALI_TEST_EQUALS( uniform1Value, value1.Get<Vector4>(), TEST_LOCATION );
 944
 945   float uniform2Value(0.0f);
 946   DALI_TEST_CHECK( gl.GetUniformValue<float>( "uUniform2", uniform2Value ) );
 947   DALI_TEST_EQUALS( uniform2Value, value2.Get<float>(), TEST_LOCATION );
 948
 949   Vector3 uniform3Value(Vector3::ZERO);
 950   DALI_TEST_CHECK( gl.GetUniformValue<Vector3>( "uUniform3", uniform3Value ) );
 951   DALI_TEST_EQUALS( uniform3Value, value3.Get<Vector3>(), TEST_LOCATION );
 952
 953   Vector2 uniform4Value(Vector2::ZERO);
 954   DALI_TEST_CHECK( gl.GetUniformValue<Vector2>( "uUniform4", uniform4Value ) );
 955   DALI_TEST_EQUALS( uniform4Value, value4.Get<Vector2>(), TEST_LOCATION );
 956
 957   Matrix3 uniform5Value;
 958   DALI_TEST_CHECK( gl.GetUniformValue<Matrix3>( "uUniform5", uniform5Value ) );
 959   DALI_TEST_EQUALS( uniform5Value, value5.Get<Matrix3>(), TEST_LOCATION );
 960
 961   Matrix uniform6Value;
 962   DALI_TEST_CHECK( gl.GetUniformValue<Matrix>( "uUniform6", uniform6Value ) );
 963   DALI_TEST_EQUALS( uniform6Value, value6.Get<Matrix>(), TEST_LOCATION );
 964
 965   int uniform7Value = 0;
 966   DALI_TEST_CHECK( gl.GetUniformValue<int>( "uUniform7", uniform7Value ) );
 967   DALI_TEST_EQUALS( uniform7Value, value7.Get<int>(), TEST_LOCATION );
 968
 969   END_TEST;
 970 }