automated-tests/src/dali-toolkit/utc-Dali-RendererFactory.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 #include <iostream>
  18 #include <stdlib.h>
  19 #include <dali-toolkit-test-suite-utils.h>
  20 #include <dali/devel-api/rendering/renderer.h>
  21 #include <dali/devel-api/rendering/material.h>
  22 #include <dali/devel-api/rendering/shader.h>
  23 #include <dali-toolkit/devel-api/controls/renderer-factory/renderer-factory.h>
  24
  25 using namespace Dali;
  26 using namespace Dali::Toolkit;
  27
  28 namespace
  29 {
  30 const char* TEST_IMAGE_FILE_NAME =  "gallery_image_01.jpg";
  31 const char* TEST_NPATCH_FILE_NAME =  "gallery_image_01.9.jpg";
  32
  33 Integration::Bitmap* CreateBitmap( unsigned int imageWidth, unsigned int imageHeight, unsigned int initialColor, Pixel::Format pixelFormat )
  34 {
  35   Integration::Bitmap* bitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_RETAIN );
  36   Integration::PixelBuffer* pixbuffer = bitmap->GetPackedPixelsProfile()->ReserveBuffer( pixelFormat, imageWidth, imageHeight, imageWidth, imageHeight );
  37   unsigned int bytesPerPixel = GetBytesPerPixel( pixelFormat );
  38
  39   memset( pixbuffer, initialColor, imageHeight * imageWidth * bytesPerPixel );
  40
  41   return bitmap;
  42 }
  43
  44 void InitialiseRegionsToZeroAlpha( Integration::Bitmap* image, unsigned int imageWidth, unsigned int imageHeight, Pixel::Format pixelFormat )
  45 {
  46   PixelBuffer* pixbuffer = image->GetBuffer();
  47   unsigned int bytesPerPixel = GetBytesPerPixel( pixelFormat );
  48
  49   for( unsigned int row = 0; row < imageWidth; ++row )
  50   {
  51     unsigned int pixelOffset = row * bytesPerPixel;
  52     pixbuffer[ pixelOffset + 3 ] = 0x00;
  53     pixelOffset += ( imageHeight - 1 ) * imageWidth * bytesPerPixel;
  54     pixbuffer[ pixelOffset + 3 ] = 0x00;
  55   }
  56
  57   for ( unsigned int column = 0; column < imageHeight; ++column )
  58   {
  59     unsigned int pixelOffset = column * imageWidth * bytesPerPixel;
  60     pixbuffer[ pixelOffset + 3 ] = 0x00;
  61     pixelOffset += ( imageWidth -1 ) * bytesPerPixel;
  62     pixbuffer[ pixelOffset + 3 ] = 0x00;
  63   }
  64 }
  65
  66 void AddStretchRegionsToImage( Integration::Bitmap* image, unsigned int imageWidth, unsigned int imageHeight, const Vector4& requiredStretchBorder, Pixel::Format pixelFormat )
  67 {
  68   PixelBuffer* pixbuffer = image->GetBuffer();
  69   unsigned int bytesPerPixel = GetBytesPerPixel( pixelFormat );
  70
  71   for( unsigned int column = requiredStretchBorder.x; column < imageWidth - requiredStretchBorder.z; ++column )
  72   {
  73     unsigned int pixelOffset = column * bytesPerPixel;
  74     pixbuffer[ pixelOffset ] = 0x00;
  75     pixbuffer[ pixelOffset + 1 ] = 0x00;
  76     pixbuffer[ pixelOffset + 2 ] = 0x00;
  77     pixbuffer[ pixelOffset + 3 ] = 0xFF;
  78   }
  79
  80   for( unsigned int row = requiredStretchBorder.y; row < imageHeight - requiredStretchBorder.w; ++row )
  81   {
  82     unsigned int pixelOffset = row * imageWidth * bytesPerPixel;
  83     pixbuffer[ pixelOffset ] = 0x00;
  84     pixbuffer[ pixelOffset + 1 ] = 0x00;
  85     pixbuffer[ pixelOffset + 2 ] = 0x00;
  86     pixbuffer[ pixelOffset + 3 ] = 0xFF;
  87   }
  88 }
  89
  90 void AddChildRegionsToImage( Integration::Bitmap* image, unsigned int imageWidth, unsigned int imageHeight, const Vector4& requiredChildRegion, Pixel::Format pixelFormat )
  91 {
  92   PixelBuffer* pixbuffer = image->GetBuffer();
  93   unsigned int bytesPerPixel = GetBytesPerPixel( pixelFormat );
  94
  95   Integration::Bitmap::PackedPixelsProfile* srcProfile = image->GetPackedPixelsProfile();
  96   unsigned int bufferStride = srcProfile->GetBufferStride();
  97
  98   // Add bottom child region
  99   for( unsigned int column = requiredChildRegion.x; column < imageWidth - requiredChildRegion.z; ++column )
 100   {
 101     unsigned int pixelOffset = column * bytesPerPixel;
 102     pixelOffset += ( imageHeight - 1 ) * bufferStride;
 103     pixbuffer[ pixelOffset ] = 0x00;
 104     pixbuffer[ pixelOffset + 1 ] = 0x00;
 105     pixbuffer[ pixelOffset + 2 ] = 0x00;
 106     pixbuffer[ pixelOffset + 3 ] = 0xFF;
 107   }
 108
 109   // Add right child region
 110   for ( unsigned int row = requiredChildRegion.y; row < imageHeight - requiredChildRegion.w; ++row )
 111   {
 112     unsigned int pixelOffset = row * bufferStride + ( imageWidth - 1 ) * bytesPerPixel;
 113     pixbuffer[ pixelOffset ] = 0x00;
 114     pixbuffer[ pixelOffset + 1 ] = 0x00;
 115     pixbuffer[ pixelOffset + 2 ] = 0x00;
 116     pixbuffer[ pixelOffset + 3 ] = 0xFF;
 117   }
 118 }
 119
 120 Integration::ResourcePointer CustomizeNinePatch( TestApplication& application,
 121                                                  unsigned int ninePatchImageWidth,
 122                                                  unsigned int ninePatchImageHeight,
 123                                                  const Vector4& requiredStretchBorder,
 124                                                  bool addChildRegion = false,
 125                                                  Vector4 requiredChildRegion = Vector4::ZERO )
 126 {
 127   TestPlatformAbstraction& platform = application.GetPlatform();
 128
 129   Pixel::Format pixelFormat = Pixel::RGBA8888;
 130
 131   tet_infoline("Create Bitmap");
 132   platform.SetClosestImageSize(Vector2( ninePatchImageWidth, ninePatchImageHeight));
 133   Integration::Bitmap* bitmap = CreateBitmap( ninePatchImageWidth, ninePatchImageHeight, 0xFF, pixelFormat );
 134
 135   tet_infoline("Clear border regions");
 136   InitialiseRegionsToZeroAlpha( bitmap, ninePatchImageWidth, ninePatchImageHeight, pixelFormat );
 137
 138   tet_infoline("Add Stretch regions to Bitmap");
 139   AddStretchRegionsToImage( bitmap, ninePatchImageWidth, ninePatchImageHeight, requiredStretchBorder, pixelFormat );
 140
 141   if( addChildRegion )
 142   {
 143     tet_infoline("Add Child regions to Bitmap");
 144     AddChildRegionsToImage( bitmap, ninePatchImageWidth, ninePatchImageHeight, requiredChildRegion, pixelFormat );
 145   }
 146
 147   tet_infoline("Getting resource");
 148   Integration::ResourcePointer resourcePtr(bitmap);
 149   platform.SetResourceLoaded( 0, Dali::Integration::ResourceBitmap, resourcePtr );
 150
 151   return resourcePtr;
 152 }
 153
 154 } // namespace
 155
 156
 157 void dali_renderer_factory_startup(void)
 158 {
 159   test_return_value = TET_UNDEF;
 160 }
 161
 162 void dali_renderer_factory_cleanup(void)
 163 {
 164   test_return_value = TET_PASS;
 165 }
 166
 167 int UtcDaliRendererFactoryGet(void)
 168 {
 169   ToolkitTestApplication application;
 170   tet_infoline( "UtcDaliRendererFactory" );
 171
 172   //Register type
 173   TypeInfo type;
 174   type = TypeRegistry::Get().GetTypeInfo( "RendererFactory" );
 175   DALI_TEST_CHECK( type );
 176   BaseHandle handle = type.CreateInstance();
 177   DALI_TEST_CHECK( handle );
 178
 179   RendererFactory factory;
 180   factory = RendererFactory::Get();
 181   DALI_TEST_CHECK( factory );
 182
 183   RendererFactory newFactory = RendererFactory::Get();
 184   DALI_TEST_CHECK( newFactory );
 185
 186   // Check that renderer factory is a singleton
 187   DALI_TEST_CHECK(factory == newFactory);
 188
 189   END_TEST;
 190 }
 191
 192 int UtcDaliRendererFactoryCopyAndAssignment(void)
 193 {
 194   ToolkitTestApplication application;
 195   tet_infoline( "UtcDaliRendererFactoryCopyAndAssignment" );
 196   RendererFactory factory = RendererFactory::Get();
 197
 198   RendererFactory factoryCopy( factory );
 199   DALI_TEST_CHECK(factory == factoryCopy);
 200
 201   RendererFactory emptyFactory;
 202   RendererFactory emptyFactoryCopy( emptyFactory );
 203   DALI_TEST_CHECK(emptyFactory == emptyFactoryCopy);
 204
 205   RendererFactory factoryEquals;
 206   factoryEquals = factory;
 207   DALI_TEST_CHECK(factory == factoryEquals);
 208
 209   RendererFactory emptyFactoryEquals;
 210   emptyFactoryEquals = emptyFactory;
 211   DALI_TEST_CHECK( emptyFactory == emptyFactoryEquals );
 212
 213   //self assignment
 214   factory = factory;
 215   DALI_TEST_CHECK( factory = factoryCopy );
 216
 217   END_TEST;
 218 }
 219
 220 int UtcDaliRendererFactoryGetColorRenderer1(void)
 221 {
 222   ToolkitTestApplication application;
 223   tet_infoline( "UtcDaliRendererFactoryGetColorRenderer1:  Request color renderer with a Property::Map" );
 224
 225   RendererFactory factory = RendererFactory::Get();
 226   DALI_TEST_CHECK( factory );
 227
 228   Property::Map propertyMap;
 229   Vector4 testColor( 1.f, 0.5f, 0.3f, 0.2f );
 230   propertyMap.Insert("renderer-type", "color-renderer");
 231   propertyMap.Insert("blend-color", testColor);
 232
 233   ControlRenderer controlRenderer = factory.GetControlRenderer(propertyMap);
 234   DALI_TEST_CHECK( controlRenderer );
 235
 236   Actor actor = Actor::New();
 237   actor.SetSize(200.f, 200.f);
 238   Stage::GetCurrent().Add( actor );
 239   controlRenderer.SetSize(Vector2(200.f, 200.f));
 240   controlRenderer.SetOnStage( actor );
 241
 242   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 243
 244   TestGlAbstraction& gl = application.GetGlAbstraction();
 245
 246   application.SendNotification();
 247   application.Render(0);
 248
 249   Vector4 actualValue(Vector4::ZERO);
 250   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uBlendColor", actualValue ) );
 251   DALI_TEST_EQUALS( actualValue, testColor, TEST_LOCATION );
 252
 253   END_TEST;
 254 }
 255
 256 int UtcDaliRendererFactoryGetColorRenderer2(void)
 257 {
 258   ToolkitTestApplication application;
 259   tet_infoline( "UtcDaliRendererFactoryGetColorRenderer2: Request color renderer with a Vector4" );
 260
 261   RendererFactory factory = RendererFactory::Get();
 262   DALI_TEST_CHECK( factory );
 263
 264   Vector4 testColor( 1.f, 0.5f, 0.3f, 0.2f );
 265   ControlRenderer controlRenderer = factory.GetControlRenderer(testColor);
 266   DALI_TEST_CHECK( controlRenderer );
 267
 268   Actor actor = Actor::New();
 269   actor.SetSize(200.f, 200.f);
 270   Stage::GetCurrent().Add( actor );
 271   controlRenderer.SetSize(Vector2(200.f, 200.f));
 272   controlRenderer.SetOnStage( actor );
 273
 274   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 275
 276   TestGlAbstraction& gl = application.GetGlAbstraction();
 277
 278   application.SendNotification();
 279   application.Render(0);
 280
 281   Vector4 actualValue(Vector4::ZERO);
 282   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uBlendColor", actualValue ) );
 283   DALI_TEST_EQUALS( actualValue, testColor, TEST_LOCATION );
 284
 285   controlRenderer.SetOffStage( actor );
 286   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 287
 288   END_TEST;
 289 }
 290
 291 int UtcDaliRendererFactoryGetBorderRenderer1(void)
 292 {
 293   ToolkitTestApplication application;
 294   tet_infoline( "UtcDaliRendererFactoryGetBorderRenderer1:  Request border renderer with a Property::Map" );
 295
 296   RendererFactory factory = RendererFactory::Get();
 297   DALI_TEST_CHECK( factory );
 298
 299   Property::Map propertyMap;
 300   Vector4 testColor( 1.f, 0.5f, 0.3f, 0.2f );
 301   float testSize = 5.f;
 302   propertyMap.Insert("renderer-type", "border-renderer");
 303   propertyMap.Insert("border-color", testColor);
 304   propertyMap.Insert("border-size", testSize);
 305
 306   ControlRenderer controlRenderer = factory.GetControlRenderer(propertyMap);
 307   DALI_TEST_CHECK( controlRenderer );
 308
 309   Actor actor = Actor::New();
 310   actor.SetSize(200.f, 200.f);
 311   Stage::GetCurrent().Add( actor );
 312   controlRenderer.SetSize(Vector2(200.f, 200.f));
 313   controlRenderer.SetOnStage( actor );
 314
 315   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 316
 317   TestGlAbstraction& gl = application.GetGlAbstraction();
 318
 319   application.SendNotification();
 320   application.Render(0);
 321
 322   Vector4 actualColor(Vector4::ZERO);
 323   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uBorderColor", actualColor ) );
 324   DALI_TEST_EQUALS( actualColor, testColor, TEST_LOCATION );
 325
 326   float actualSize = 0.f;
 327   DALI_TEST_CHECK( gl.GetUniformValue<float>( "uBorderSize", actualSize ) );
 328   DALI_TEST_EQUALS( actualSize, testSize, TEST_LOCATION );
 329
 330   controlRenderer.SetOffStage( actor );
 331   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 332
 333   END_TEST;
 334 }
 335
 336 int UtcDaliRendererFactoryGetBorderRenderer2(void)
 337 {
 338   ToolkitTestApplication application;
 339   tet_infoline( "UtcDaliRendererFactoryGetBorderRenderer2:  Request border renderer with a borderSize and a borderColor" );
 340
 341   RendererFactory factory = RendererFactory::Get();
 342   DALI_TEST_CHECK( factory );
 343
 344   Vector4 testColor( 1.f, 0.5f, 0.3f, 0.2f );
 345   float testSize = 5.f;
 346
 347   ControlRenderer controlRenderer = factory.GetControlRenderer(testSize, testColor);
 348   DALI_TEST_CHECK( controlRenderer );
 349
 350   Actor actor = Actor::New();
 351   actor.SetSize(200.f, 200.f);
 352   Stage::GetCurrent().Add( actor );
 353   controlRenderer.SetSize(Vector2(200.f, 200.f));
 354   controlRenderer.SetOnStage( actor );
 355
 356   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 357
 358   TestGlAbstraction& gl = application.GetGlAbstraction();
 359
 360   application.SendNotification();
 361   application.Render(0);
 362
 363   Vector4 actualColor(Vector4::ZERO);
 364   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uBorderColor", actualColor ) );
 365   DALI_TEST_EQUALS( actualColor, testColor, TEST_LOCATION );
 366
 367   float actualSize = 0.f;
 368   DALI_TEST_CHECK( gl.GetUniformValue<float>( "uBorderSize", actualSize ) );
 369   DALI_TEST_EQUALS( actualSize, testSize, TEST_LOCATION );
 370
 371   END_TEST;
 372 }
 373
 374
 375 int UtcDaliRendererFactoryGetLinearGradientRenderer(void)
 376 {
 377   ToolkitTestApplication application;
 378   tet_infoline("UtcDaliRendererFactoryGetRadialGradientRenderer");
 379
 380   RendererFactory factory = RendererFactory::Get();
 381   DALI_TEST_CHECK( factory );
 382
 383   Property::Map propertyMap;
 384   propertyMap.Insert("renderer-type", "gradient-renderer");
 385
 386   Vector2 start(-1.f, -1.f);
 387   Vector2 end(1.f, 1.f);
 388   propertyMap.Insert("gradient-start-position", start);
 389   propertyMap.Insert("gradient-end-position", end);
 390   propertyMap.Insert("gradient-spread-method", "repeat");
 391
 392   Property::Array stopOffsets;
 393   stopOffsets.PushBack( 0.2f );
 394   stopOffsets.PushBack( 0.8f );
 395   propertyMap.Insert("gradient-stop-offset", stopOffsets);
 396
 397   Property::Array stopColors;
 398   stopColors.PushBack( Color::RED );
 399   stopColors.PushBack( Color::GREEN );
 400   propertyMap.Insert("gradient-stop-color", stopColors);
 401
 402   ControlRenderer controlRenderer = factory.GetControlRenderer(propertyMap);
 403   DALI_TEST_CHECK( controlRenderer );
 404
 405   Actor actor = Actor::New();
 406   Vector2 size(200.f, 200.f);
 407   actor.SetSize(size);
 408   Stage::GetCurrent().Add( actor );
 409   controlRenderer.SetOnStage( actor );
 410   controlRenderer.SetSize(size);
 411
 412   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 413
 414   // A lookup texture is generated and pass to shader as sampler
 415   DALI_TEST_CHECK( actor.GetRendererAt(0u).GetMaterial().GetNumberOfSamplers() == 1u );
 416
 417   application.SendNotification();
 418   application.Render(0);
 419
 420   controlRenderer.SetOffStage( actor );
 421   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 422
 423   END_TEST;
 424 }
 425
 426 int UtcDaliRendererFactoryGetRadialGradientRenderer(void)
 427 {
 428   ToolkitTestApplication application;
 429   tet_infoline("UtcDaliRendererFactoryGetRadialGradientRenderer");
 430
 431   RendererFactory factory = RendererFactory::Get();
 432   DALI_TEST_CHECK( factory );
 433
 434   Property::Map propertyMap;
 435   propertyMap.Insert("renderer-type", "gradient-renderer");
 436
 437   Vector2 center(100.f, 100.f);
 438   float radius = 100.f;
 439   propertyMap.Insert("gradient-units", "user-space");
 440   propertyMap.Insert("gradient-center", center);
 441   propertyMap.Insert("gradient-radius", radius);
 442
 443   Property::Array stopOffsets;
 444   stopOffsets.PushBack( 0.0f );
 445   stopOffsets.PushBack( 1.f );
 446   propertyMap.Insert("gradient-stop-offset", stopOffsets);
 447
 448   Property::Array stopColors;
 449   stopColors.PushBack( Color::RED );
 450   stopColors.PushBack( Color::GREEN );
 451   propertyMap.Insert("gradient-stop-color", stopColors);
 452
 453   ControlRenderer controlRenderer = factory.GetControlRenderer(propertyMap);
 454   DALI_TEST_CHECK( controlRenderer );
 455
 456   Actor actor = Actor::New();
 457   Vector2 size(200.f, 200.f);
 458   actor.SetSize(size);
 459   Stage::GetCurrent().Add( actor );
 460   controlRenderer.SetSize(size);
 461   controlRenderer.SetOnStage( actor );
 462
 463   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 464
 465   // A lookup texture is generated and pass to shader as sampler
 466   DALI_TEST_CHECK( actor.GetRendererAt(0u).GetMaterial().GetNumberOfSamplers() == 1u );
 467
 468   TestGlAbstraction& gl = application.GetGlAbstraction();
 469   application.SendNotification();
 470   application.Render(0);
 471
 472   Matrix3 alignMatrix( radius, 0.f, 0.f, 0.f, radius, 0.f, center.x, center.y, 1.f );
 473   alignMatrix.Invert();
 474
 475   Matrix3 actualValue( Matrix3::IDENTITY );
 476   DALI_TEST_CHECK( gl.GetUniformValue<Matrix3>( "uAlignmentMatrix", actualValue ) );
 477   DALI_TEST_EQUALS( actualValue, alignMatrix, Math::MACHINE_EPSILON_100, TEST_LOCATION );
 478
 479   END_TEST;
 480 }
 481
 482 int UtcDaliRendererFactoryGetImageRenderer1(void)
 483 {
 484   ToolkitTestApplication application;
 485   tet_infoline( "UtcDaliRendererFactoryGetImageRenderer1: Request image renderer with a Property::Map" );
 486
 487   RendererFactory factory = RendererFactory::Get();
 488   DALI_TEST_CHECK( factory );
 489
 490   Property::Map propertyMap;
 491   propertyMap.Insert( "renderer-type", "image-renderer" );
 492   propertyMap.Insert( "image-url", TEST_IMAGE_FILE_NAME );
 493
 494   ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
 495   DALI_TEST_CHECK( controlRenderer );
 496
 497   Actor actor = Actor::New();
 498   actor.SetSize( 200.f, 200.f );
 499   Stage::GetCurrent().Add( actor );
 500   controlRenderer.SetSize( Vector2(200.f, 200.f) );
 501   controlRenderer.SetOnStage( actor );
 502
 503   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 504   DALI_TEST_CHECK( actor.GetRendererAt(0u).GetMaterial().GetNumberOfSamplers() == 1u );
 505
 506   TestGlAbstraction& gl = application.GetGlAbstraction();
 507   application.SendNotification();
 508   application.Render();
 509
 510   Integration::ResourceRequest* request = application.GetPlatform().GetRequest();
 511   if(request)
 512   {
 513     application.GetPlatform().SetResourceLoaded(request->GetId(), request->GetType()->id, Integration::ResourcePointer(Integration::Bitmap::New(Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD)));
 514   }
 515
 516   application.Render();
 517   application.SendNotification();
 518
 519   DALI_TEST_CHECK(application.GetPlatform().WasCalled(TestPlatformAbstraction::LoadResourceFunc));
 520
 521   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 522
 523   int textureUnit = -1;
 524   DALI_TEST_CHECK( gl.GetUniformValue< int >( "sTexture", textureUnit ) );
 525   DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
 526
 527   controlRenderer.SetOffStage( actor );
 528   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 529
 530   END_TEST;
 531 }
 532
 533 int UtcDaliRendererFactoryGetImageRenderer2(void)
 534 {
 535   ToolkitTestApplication application;
 536   tet_infoline( "UtcDaliRendererFactoryGetImageRenderer2: Request image renderer with an image handle" );
 537
 538   RendererFactory factory = RendererFactory::Get();
 539   DALI_TEST_CHECK( factory );
 540
 541   Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME);
 542   ControlRenderer controlRenderer = factory.GetControlRenderer( image );
 543
 544   Actor actor = Actor::New();
 545   actor.SetSize( 200.f, 200.f );
 546   Stage::GetCurrent().Add( actor );
 547   controlRenderer.SetSize( Vector2(200.f, 200.f) );
 548   controlRenderer.SetOnStage( actor );
 549
 550   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 551   DALI_TEST_CHECK( actor.GetRendererAt(0u).GetMaterial().GetNumberOfSamplers() == 1u );
 552
 553   TestGlAbstraction& gl = application.GetGlAbstraction();
 554   application.SendNotification();
 555   application.Render();
 556
 557   Integration::ResourceRequest* request = application.GetPlatform().GetRequest();
 558   if(request)
 559   {
 560     application.GetPlatform().SetResourceLoaded(request->GetId(), request->GetType()->id, Integration::ResourcePointer(Integration::Bitmap::New(Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD)));
 561   }
 562
 563   application.Render();
 564   application.SendNotification();
 565
 566   DALI_TEST_CHECK(application.GetPlatform().WasCalled(TestPlatformAbstraction::LoadResourceFunc));
 567
 568   int textureUnit = -1;
 569   DALI_TEST_CHECK( gl.GetUniformValue< int >( "sTexture", textureUnit ) );
 570   DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
 571
 572   END_TEST;
 573 }
 574
 575 int UtcDaliRendererFactoryGetNPatchRenderer1(void)
 576 {
 577   ToolkitTestApplication application;
 578   tet_infoline( "UtcDaliRendererFactoryGetNPatchRenderer1: Request n-patch renderer with a Property::Map" );
 579
 580   RendererFactory factory = RendererFactory::Get();
 581   DALI_TEST_CHECK( factory );
 582
 583   const unsigned int ninePatchImageHeight = 18;
 584   const unsigned int ninePatchImageWidth = 28;
 585   const Vector4 requiredStretchBorder( 3, 4, 5, 6 );
 586   Integration::ResourcePointer ninePatchResource = CustomizeNinePatch( application, ninePatchImageWidth, ninePatchImageHeight, requiredStretchBorder );
 587
 588   Property::Map propertyMap;
 589   propertyMap.Insert( "renderer-type", "n-patch-renderer" );
 590   propertyMap.Insert( "image-url", TEST_NPATCH_FILE_NAME );
 591
 592   ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
 593   DALI_TEST_CHECK( controlRenderer );
 594
 595   Actor actor = Actor::New();
 596   actor.SetSize( 200.f, 200.f );
 597   Stage::GetCurrent().Add( actor );
 598   controlRenderer.SetSize( Vector2(200.f, 200.f) );
 599   controlRenderer.SetOnStage( actor );
 600
 601   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 602   DALI_TEST_CHECK( actor.GetRendererAt(0u).GetMaterial().GetNumberOfSamplers() == 1u );
 603
 604   TestGlAbstraction& gl = application.GetGlAbstraction();
 605   application.SendNotification();
 606   application.Render();
 607
 608   Integration::ResourceRequest* request = application.GetPlatform().GetRequest();
 609   if(request)
 610   {
 611     application.GetPlatform().SetResourceLoaded(request->GetId(), request->GetType()->id, ninePatchResource );
 612   }
 613
 614   application.Render();
 615   application.SendNotification();
 616
 617   DALI_TEST_CHECK(application.GetPlatform().WasCalled(TestPlatformAbstraction::LoadResourceFunc));
 618
 619   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 620
 621   int textureUnit = -1;
 622   DALI_TEST_CHECK( gl.GetUniformValue< int >( "sTexture", textureUnit ) );
 623   DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
 624
 625   controlRenderer.SetOffStage( actor );
 626   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 627
 628   END_TEST;
 629 }
 630
 631 int UtcDaliRendererFactoryGetNPatchRenderer2(void)
 632 {
 633   ToolkitTestApplication application;
 634   tet_infoline( "UtcDaliRendererFactoryGetNPatchRenderer2: Request n-patch renderer with an image url" );
 635
 636   RendererFactory factory = RendererFactory::Get();
 637   DALI_TEST_CHECK( factory );
 638
 639   const unsigned int ninePatchImageHeight = 18;
 640   const unsigned int ninePatchImageWidth = 28;
 641   const Vector4 requiredStretchBorder( 3, 4, 5, 6 );
 642   Integration::ResourcePointer ninePatchResource = CustomizeNinePatch( application, ninePatchImageWidth, ninePatchImageHeight, requiredStretchBorder );
 643
 644   ControlRenderer controlRenderer = factory.GetControlRenderer( TEST_NPATCH_FILE_NAME );
 645   DALI_TEST_CHECK( controlRenderer );
 646
 647   Actor actor = Actor::New();
 648   actor.SetSize( 200.f, 200.f );
 649   Stage::GetCurrent().Add( actor );
 650   controlRenderer.SetSize( Vector2(200.f, 200.f) );
 651   controlRenderer.SetOnStage( actor );
 652
 653   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 654   DALI_TEST_CHECK( actor.GetRendererAt(0u).GetMaterial().GetNumberOfSamplers() == 1u );
 655
 656   TestGlAbstraction& gl = application.GetGlAbstraction();
 657   application.SendNotification();
 658   application.Render();
 659
 660   Integration::ResourceRequest* request = application.GetPlatform().GetRequest();
 661   if(request)
 662   {
 663     application.GetPlatform().SetResourceLoaded(request->GetId(), request->GetType()->id, ninePatchResource );
 664   }
 665
 666   application.Render();
 667   application.SendNotification();
 668
 669   DALI_TEST_CHECK(application.GetPlatform().WasCalled(TestPlatformAbstraction::LoadResourceFunc));
 670
 671   int textureUnit = -1;
 672   DALI_TEST_CHECK( gl.GetUniformValue< int >( "sTexture", textureUnit ) );
 673   DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
 674
 675   END_TEST;
 676 }
 677
 678 int UtcDaliRendererFactoryGetNPatchRendererN1(void)
 679 {
 680   //This should still load but display an error image
 681
 682   ToolkitTestApplication application;
 683   tet_infoline( "UtcDaliRendererFactoryGetNPatchRendererN: Request n-patch renderer with an invalid image url" );
 684
 685   RendererFactory factory = RendererFactory::Get();
 686   DALI_TEST_CHECK( factory );
 687
 688   ControlRenderer controlRenderer = factory.GetControlRenderer( "ERROR.9.jpg" );
 689   DALI_TEST_CHECK( controlRenderer );
 690
 691   Actor actor = Actor::New();
 692   actor.SetSize( 200.f, 200.f );
 693   Stage::GetCurrent().Add( actor );
 694   controlRenderer.SetSize( Vector2(200.f, 200.f) );
 695   controlRenderer.SetOnStage( actor );
 696
 697   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 698   DALI_TEST_CHECK( actor.GetRendererAt(0u).GetMaterial().GetNumberOfSamplers() == 1u );
 699
 700   TestGlAbstraction& gl = application.GetGlAbstraction();
 701   application.SendNotification();
 702   application.Render();
 703
 704   int textureUnit = -1;
 705   DALI_TEST_CHECK( gl.GetUniformValue< int >( "sTexture", textureUnit ) );
 706   DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
 707
 708   END_TEST;
 709 }
 710
 711 int UtcDaliRendererFactoryGetNPatchRendererN2(void)
 712 {
 713   //This should still load but display an error image
 714
 715   ToolkitTestApplication application;
 716   tet_infoline( "UtcDaliRendererFactoryGetNPatchRendererN: Request n-patch renderer with an invalid Property::Map" );
 717
 718   RendererFactory factory = RendererFactory::Get();
 719   DALI_TEST_CHECK( factory );
 720
 721   Property::Map propertyMap;
 722   propertyMap.Insert( "renderer-type", "n-patch-renderer" );
 723   propertyMap.Insert( "image-url", 111 );
 724
 725   ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
 726   DALI_TEST_CHECK( controlRenderer );
 727
 728   Actor actor = Actor::New();
 729   actor.SetSize( 200.f, 200.f );
 730   Stage::GetCurrent().Add( actor );
 731   controlRenderer.SetSize( Vector2(200.f, 200.f) );
 732   controlRenderer.SetOnStage( actor );
 733
 734   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 735   DALI_TEST_CHECK( actor.GetRendererAt(0u).GetMaterial().GetNumberOfSamplers() == 1u );
 736
 737   TestGlAbstraction& gl = application.GetGlAbstraction();
 738   application.SendNotification();
 739   application.Render();
 740
 741   int textureUnit = -1;
 742   DALI_TEST_CHECK( gl.GetUniformValue< int >( "sTexture", textureUnit ) );
 743   DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
 744
 745   END_TEST;
 746 }
 747
 748 int UtcDaliRendererFactoryResetRenderer1(void)
 749 {
 750   ToolkitTestApplication application;
 751   tet_infoline( "UtcDaliRendererFactoryResetRenderer1" );
 752
 753   Actor actor = Actor::New();
 754   actor.SetSize(200.f, 200.f);
 755   Stage::GetCurrent().Add( actor );
 756
 757   RendererFactory factory = RendererFactory::Get();
 758   DALI_TEST_CHECK( factory );
 759
 760   ControlRenderer controlRenderer = factory.GetControlRenderer( Color::RED );
 761   DALI_TEST_CHECK( controlRenderer );
 762   controlRenderer.SetSize(Vector2(200.f, 200.f));
 763   controlRenderer.SetOnStage( actor );
 764   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 765
 766   TestGlAbstraction& gl = application.GetGlAbstraction();
 767   application.SendNotification();
 768   application.Render(0);
 769   Vector4 actualValue(Vector4::ZERO);
 770   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uBlendColor", actualValue ) );
 771   DALI_TEST_EQUALS( actualValue, Color::RED, TEST_LOCATION );
 772
 773   bool isNewRenderer = factory.ResetRenderer( controlRenderer, Color::GREEN );
 774   DALI_TEST_CHECK( !isNewRenderer );
 775   application.SendNotification();
 776   application.Render(0);
 777   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uBlendColor", actualValue ) );
 778   DALI_TEST_EQUALS( actualValue, Color::GREEN, TEST_LOCATION );
 779
 780   Image bufferImage = CreateBufferImage( 100, 200, Vector4( 1.f, 1.f, 1.f, 1.f ) );
 781   isNewRenderer = factory.ResetRenderer( controlRenderer, bufferImage );
 782   DALI_TEST_CHECK( isNewRenderer );
 783
 784   Actor actor2 = Actor::New();
 785   actor2.SetSize(200.f, 200.f);
 786   Stage::GetCurrent().Add( actor2 );
 787   controlRenderer.SetSize(Vector2(200.f, 200.f));
 788   controlRenderer.SetOnStage( actor2 );
 789   application.SendNotification();
 790   application.Render(0);
 791   Image samplerImage = actor2.GetRendererAt(0u).GetMaterial().GetSamplerAt(0u).GetImage();
 792   DALI_TEST_CHECK( BufferImage::DownCast( samplerImage ) );
 793
 794   END_TEST;
 795 }
 796
 797 int UtcDaliRendererFactoryResetRenderer2(void)
 798 {
 799   ToolkitTestApplication application;
 800   tet_infoline( "UtcDaliRendererFactoryResetRenderer2" );
 801
 802   Actor actor = Actor::New();
 803   actor.SetSize(200.f, 200.f);
 804   Stage::GetCurrent().Add( actor );
 805   RendererFactory factory = RendererFactory::Get();
 806   DALI_TEST_CHECK( factory );
 807
 808   Image resourceImage = ResourceImage::New(TEST_IMAGE_FILE_NAME);
 809   ControlRenderer controlRenderer = factory.GetControlRenderer( resourceImage );
 810   DALI_TEST_CHECK( controlRenderer );
 811   controlRenderer.SetSize(Vector2(200.f, 200.f));
 812   controlRenderer.SetOnStage( actor );
 813   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 814
 815   application.SendNotification();
 816   application.Render(0);
 817   Image samplerImage = actor.GetRendererAt(0u).GetMaterial().GetSamplerAt(0u).GetImage();
 818   DALI_TEST_CHECK( ResourceImage::DownCast( samplerImage ) );
 819
 820   Image bufferImage = CreateBufferImage( 100, 200, Vector4( 1.f, 1.f, 1.f, 1.f ) );
 821   bool isNewRenderer = factory.ResetRenderer( controlRenderer, bufferImage );
 822   DALI_TEST_CHECK( !isNewRenderer );
 823   application.SendNotification();
 824   application.Render(0);
 825   samplerImage = actor.GetRendererAt(0u).GetMaterial().GetSamplerAt(0u).GetImage();
 826   DALI_TEST_CHECK( BufferImage::DownCast( samplerImage ) );
 827
 828   isNewRenderer = factory.ResetRenderer( controlRenderer, Color::RED );
 829   DALI_TEST_CHECK( isNewRenderer );
 830
 831   Actor actor2 = Actor::New();
 832   actor2.SetSize(200.f, 200.f);
 833   Stage::GetCurrent().Add( actor2 );
 834   controlRenderer.SetSize(Vector2(200.f, 200.f));
 835   controlRenderer.SetOnStage( actor2 );
 836   TestGlAbstraction& gl = application.GetGlAbstraction();
 837   application.SendNotification();
 838   application.Render(0);
 839   Vector4 actualValue(Vector4::ZERO);
 840   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uBlendColor", actualValue ) );
 841   DALI_TEST_EQUALS( actualValue, Color::RED, TEST_LOCATION );
 842
 843   END_TEST;
 844 }