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