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",  "colorRenderer");
 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",  "borderRenderer");
 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   DALI_TEST_EQUALS( actor.GetRendererAt(0).GetMaterial().GetBlendMode(), BlendingMode::ON, TEST_LOCATION );
 358
 359   TestGlAbstraction& gl = application.GetGlAbstraction();
 360
 361   application.SendNotification();
 362   application.Render(0);
 363
 364   Vector4 actualColor(Vector4::ZERO);
 365   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "borderColor", actualColor ) );
 366   DALI_TEST_EQUALS( actualColor, testColor, TEST_LOCATION );
 367
 368   float actualSize = 0.f;
 369   DALI_TEST_CHECK( gl.GetUniformValue<float>( "borderSize", actualSize ) );
 370   DALI_TEST_EQUALS( actualSize, testSize, TEST_LOCATION );
 371
 372   controlRenderer.SetOffStage( actor );
 373   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 374
 375   END_TEST;
 376 }
 377
 378 int UtcDaliRendererFactoryGetBorderRenderer2(void)
 379 {
 380   ToolkitTestApplication application;
 381   tet_infoline( "UtcDaliRendererFactoryGetBorderRenderer2:  Request border renderer with a borderSize and a borderColor" );
 382
 383   RendererFactory factory = RendererFactory::Get();
 384   DALI_TEST_CHECK( factory );
 385
 386   Vector4 testColor( 1.f, 0.5f, 0.3f, 1.f );
 387   float testSize = 5.f;
 388
 389   ControlRenderer controlRenderer = factory.GetControlRenderer(testSize, testColor );
 390   DALI_TEST_CHECK( controlRenderer );
 391
 392   Actor actor = Actor::New();
 393   actor.SetSize(200.f, 200.f);
 394   Stage::GetCurrent().Add( actor );
 395   controlRenderer.SetSize(Vector2(200.f, 200.f));
 396   controlRenderer.SetOnStage( actor );
 397
 398   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 399
 400   TestGlAbstraction& gl = application.GetGlAbstraction();
 401
 402   application.SendNotification();
 403   application.Render(0);
 404
 405   DALI_TEST_EQUALS( actor.GetRendererAt(0).GetMaterial().GetBlendMode(), BlendingMode::AUTO, TEST_LOCATION );
 406
 407   Vector4 actualColor(Vector4::ZERO);
 408   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "borderColor", actualColor ) );
 409   DALI_TEST_EQUALS( actualColor, testColor, TEST_LOCATION );
 410
 411   float actualSize = 0.f;
 412   DALI_TEST_CHECK( gl.GetUniformValue<float>( "borderSize", actualSize ) );
 413   DALI_TEST_EQUALS( actualSize, testSize, TEST_LOCATION );
 414
 415   controlRenderer.SetOffStage( actor );
 416
 417   // enable the anti-aliasing
 418   controlRenderer = factory.GetControlRenderer(testSize, testColor, true );
 419   controlRenderer.SetOnStage( actor );
 420
 421   application.SendNotification();
 422   application.Render(0);
 423   DALI_TEST_EQUALS( actor.GetRendererAt(0).GetMaterial().GetBlendMode(), BlendingMode::ON, TEST_LOCATION );
 424
 425
 426   END_TEST;
 427 }
 428
 429 int UtcDaliRendererFactoryGetLinearGradientRenderer(void)
 430 {
 431   ToolkitTestApplication application;
 432   tet_infoline("UtcDaliRendererFactoryGetRadialGradientRenderer");
 433
 434   RendererFactory factory = RendererFactory::Get();
 435   DALI_TEST_CHECK( factory );
 436
 437   Property::Map propertyMap;
 438   propertyMap.Insert("rendererType",  "gradientRenderer");
 439
 440   Vector2 start(-1.f, -1.f);
 441   Vector2 end(1.f, 1.f);
 442   propertyMap.Insert("gradientStartPosition",   start);
 443   propertyMap.Insert("gradientEndPosition",   end);
 444   propertyMap.Insert("gradientSpreadMethod",   "repeat");
 445
 446   Property::Array stopOffsets;
 447   stopOffsets.PushBack( 0.2f );
 448   stopOffsets.PushBack( 0.8f );
 449   propertyMap.Insert("gradientStopOffset",   stopOffsets);
 450
 451   Property::Array stopColors;
 452   stopColors.PushBack( Color::RED );
 453   stopColors.PushBack( Color::GREEN );
 454   propertyMap.Insert("gradientStopColor",   stopColors);
 455
 456   ControlRenderer controlRenderer = factory.GetControlRenderer(propertyMap);
 457   DALI_TEST_CHECK( controlRenderer );
 458
 459   // A lookup texture is generated and pass to shader as sampler
 460   Actor actor = Actor::New();
 461   TestControlRendererRender( application, actor, controlRenderer, 1u );
 462
 463   controlRenderer.SetOffStage( actor );
 464   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 465
 466   END_TEST;
 467 }
 468
 469 int UtcDaliRendererFactoryGetRadialGradientRenderer(void)
 470 {
 471   ToolkitTestApplication application;
 472   tet_infoline("UtcDaliRendererFactoryGetRadialGradientRenderer");
 473
 474   RendererFactory factory = RendererFactory::Get();
 475   DALI_TEST_CHECK( factory );
 476
 477   Property::Map propertyMap;
 478   propertyMap.Insert("rendererType",  "gradientRenderer");
 479
 480   Vector2 center(100.f, 100.f);
 481   float radius = 100.f;
 482   propertyMap.Insert("gradientUnits",  "userSpace");
 483   propertyMap.Insert("gradientCenter",  center);
 484   propertyMap.Insert("gradientRadius",  radius);
 485
 486   Property::Array stopOffsets;
 487   stopOffsets.PushBack( 0.0f );
 488   stopOffsets.PushBack( 1.f );
 489   propertyMap.Insert("gradientStopOffset",   stopOffsets);
 490
 491   Property::Array stopColors;
 492   stopColors.PushBack( Color::RED );
 493   stopColors.PushBack( Color::GREEN );
 494   propertyMap.Insert("gradientStopColor",   stopColors);
 495
 496   ControlRenderer controlRenderer = factory.GetControlRenderer(propertyMap);
 497   DALI_TEST_CHECK( controlRenderer );
 498
 499   // A lookup texture is generated and pass to shader as sampler
 500   Actor actor = Actor::New();
 501   TestControlRendererRender( application, actor, controlRenderer, 1u );
 502
 503   Matrix3 alignMatrix( radius, 0.f, 0.f, 0.f, radius, 0.f, center.x, center.y, 1.f );
 504   alignMatrix.Invert();
 505
 506   Matrix3 actualValue( Matrix3::IDENTITY );
 507   TestGlAbstraction& gl = application.GetGlAbstraction();
 508   DALI_TEST_CHECK( gl.GetUniformValue<Matrix3>( "uAlignmentMatrix", actualValue ) );
 509   DALI_TEST_EQUALS( actualValue, alignMatrix, Math::MACHINE_EPSILON_100, TEST_LOCATION );
 510
 511   END_TEST;
 512 }
 513
 514 int UtcDaliRendererFactoryGetImageRenderer1(void)
 515 {
 516   ToolkitTestApplication application;
 517   tet_infoline( "UtcDaliRendererFactoryGetImageRenderer1: Request image renderer with a Property::Map" );
 518
 519   RendererFactory factory = RendererFactory::Get();
 520   DALI_TEST_CHECK( factory );
 521
 522   Property::Map propertyMap;
 523   propertyMap.Insert( "rendererType",  "imageRenderer" );
 524   propertyMap.Insert( "imageUrl",  TEST_IMAGE_FILE_NAME );
 525
 526   ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
 527   DALI_TEST_CHECK( controlRenderer );
 528
 529   Actor actor = Actor::New();
 530   // For tesing the LoadResourceFunc is called, a big image size should be set, so the atlasing is not applied.
 531   // Image with a size smaller than 512*512 will be uploaded as a part of the atlas.
 532   TestControlRendererRender( application, actor, controlRenderer, 1u,
 533                              ImageDimensions(512, 513),
 534                              Integration::ResourcePointer(Integration::Bitmap::New(Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD)));
 535
 536   TestGlAbstraction& gl = application.GetGlAbstraction();
 537   int textureUnit = -1;
 538   DALI_TEST_CHECK( gl.GetUniformValue< int >( "sTexture", textureUnit ) );
 539   DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
 540
 541   controlRenderer.SetOffStage( actor );
 542   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 543
 544   END_TEST;
 545 }
 546
 547 int UtcDaliRendererFactoryGetImageRenderer2(void)
 548 {
 549   ToolkitTestApplication application;
 550   tet_infoline( "UtcDaliRendererFactoryGetImageRenderer2: Request image renderer with an image handle" );
 551
 552   RendererFactory factory = RendererFactory::Get();
 553   DALI_TEST_CHECK( factory );
 554
 555   Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME);
 556   ControlRenderer controlRenderer = factory.GetControlRenderer( image );
 557
 558   Actor actor = Actor::New();
 559   // For tesing the LoadResourceFunc is called, a big image size should be set, so the atlasing is not applied.
 560   // Image with a size smaller than 512*512 will be uploaded as a part of the atlas.
 561   TestControlRendererRender( application, actor, controlRenderer, 1u,
 562                              ImageDimensions(512, 513),
 563                              Integration::ResourcePointer(Integration::Bitmap::New(Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD)) );
 564
 565   TestGlAbstraction& gl = application.GetGlAbstraction();
 566   int textureUnit = -1;
 567   DALI_TEST_CHECK( gl.GetUniformValue< int >( "sTexture", textureUnit ) );
 568   DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
 569
 570   END_TEST;
 571 }
 572
 573 int UtcDaliRendererFactoryGetNPatchRenderer1(void)
 574 {
 575   ToolkitTestApplication application;
 576   tet_infoline( "UtcDaliRendererFactoryGetNPatchRenderer1: Request 9-patch renderer with a Property::Map" );
 577
 578   RendererFactory factory = RendererFactory::Get();
 579   DALI_TEST_CHECK( factory );
 580
 581   const unsigned int ninePatchImageHeight = 18;
 582   const unsigned int ninePatchImageWidth = 28;
 583   StretchRanges stretchRangesX;
 584   stretchRangesX.PushBack( Uint16Pair( 2, 3 ) );
 585   StretchRanges stretchRangesY;
 586   stretchRangesY.PushBack( Uint16Pair( 4, 5 ) );
 587   Integration::ResourcePointer ninePatchResource = CustomizeNinePatch( application, ninePatchImageWidth, ninePatchImageHeight, stretchRangesX, stretchRangesY );
 588
 589   Property::Map propertyMap;
 590   propertyMap.Insert( "rendererType",  "nPatchRenderer" );
 591   propertyMap.Insert( "imageUrl",  TEST_NPATCH_FILE_NAME );
 592   {
 593     tet_infoline( "whole grid" );
 594     ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
 595     DALI_TEST_CHECK( controlRenderer );
 596
 597     Actor actor = Actor::New();
 598     TestControlRendererRender( application, actor, controlRenderer, 1u,
 599                                ImageDimensions(ninePatchImageWidth, ninePatchImageHeight),
 600                                ninePatchResource );
 601
 602     TestGlAbstraction& gl = application.GetGlAbstraction();
 603     int textureUnit = -1;
 604     DALI_TEST_CHECK( gl.GetUniformValue< int >( "sTexture", textureUnit ) );
 605     DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
 606   }
 607
 608   propertyMap.Insert( "borderOnly",  true );
 609   {
 610     tet_infoline( "border only" );
 611     ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
 612     DALI_TEST_CHECK( controlRenderer );
 613
 614     Actor actor = Actor::New();
 615     TestControlRendererRender( application, actor, controlRenderer, 1u,
 616                                ImageDimensions(ninePatchImageWidth, ninePatchImageHeight),
 617                                ninePatchResource );
 618
 619     TestGlAbstraction& gl = application.GetGlAbstraction();
 620     int textureUnit = -1;
 621     DALI_TEST_CHECK( gl.GetUniformValue< int >( "sTexture", textureUnit ) );
 622     DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
 623   }
 624
 625   END_TEST;
 626 }
 627
 628 int UtcDaliRendererFactoryGetNPatchRenderer2(void)
 629 {
 630   ToolkitTestApplication application;
 631   tet_infoline( "UtcDaliRendererFactoryGetNPatchRenderer2: Request n-patch renderer with a Property::Map" );
 632
 633   RendererFactory factory = RendererFactory::Get();
 634   DALI_TEST_CHECK( factory );
 635
 636   const unsigned int ninePatchImageWidth = 18;
 637   const unsigned int ninePatchImageHeight = 28;
 638   StretchRanges stretchRangesX;
 639   stretchRangesX.PushBack( Uint16Pair( 2, 3 ) );
 640   stretchRangesX.PushBack( Uint16Pair( 5, 7 ) );
 641   stretchRangesX.PushBack( Uint16Pair( 12, 15 ) );
 642   StretchRanges stretchRangesY;
 643   stretchRangesY.PushBack( Uint16Pair( 4, 5 ) );
 644   stretchRangesY.PushBack( Uint16Pair( 8, 12 ) );
 645   stretchRangesY.PushBack( Uint16Pair( 15, 16 ) );
 646   stretchRangesY.PushBack( Uint16Pair( 25, 27 ) );
 647   Integration::ResourcePointer ninePatchResource = CustomizeNinePatch( application, ninePatchImageWidth, ninePatchImageHeight, stretchRangesX, stretchRangesY );
 648
 649   Property::Map propertyMap;
 650   propertyMap.Insert( "rendererType",  "nPatchRenderer" );
 651   propertyMap.Insert( "imageUrl",  TEST_NPATCH_FILE_NAME );
 652   {
 653     ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
 654     DALI_TEST_CHECK( controlRenderer );
 655
 656     Actor actor = Actor::New();
 657     TestControlRendererRender( application, actor, controlRenderer, 1u,
 658                                ImageDimensions(ninePatchImageWidth, ninePatchImageHeight),
 659                                ninePatchResource );
 660
 661     TestGlAbstraction& gl = application.GetGlAbstraction();
 662     int textureUnit = -1;
 663     DALI_TEST_CHECK( gl.GetUniformValue< int >( "sTexture", textureUnit ) );
 664     DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
 665
 666     controlRenderer.SetOffStage( actor );
 667     DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 668   }
 669
 670   propertyMap.Insert( "borderOnly",  true );
 671   {
 672     tet_infoline( "border only" );
 673     ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
 674     DALI_TEST_CHECK( controlRenderer );
 675
 676     Actor actor = Actor::New();
 677     TestControlRendererRender( application, actor, controlRenderer, 1u,
 678                                ImageDimensions(ninePatchImageWidth, ninePatchImageHeight),
 679                                ninePatchResource );
 680
 681     TestGlAbstraction& gl = application.GetGlAbstraction();
 682     int textureUnit = -1;
 683     DALI_TEST_CHECK( gl.GetUniformValue< int >( "sTexture", textureUnit ) );
 684     DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
 685
 686     controlRenderer.SetOffStage( actor );
 687     DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 688   }
 689
 690   END_TEST;
 691 }
 692
 693 int UtcDaliRendererFactoryGetNPatchRenderer3(void)
 694 {
 695   ToolkitTestApplication application;
 696   tet_infoline( "UtcDaliRendererFactoryGetNPatchRenderer3: Request 9-patch renderer with an image url" );
 697
 698   RendererFactory factory = RendererFactory::Get();
 699   DALI_TEST_CHECK( factory );
 700
 701   const unsigned int ninePatchImageHeight = 18;
 702   const unsigned int ninePatchImageWidth = 28;
 703   StretchRanges stretchRangesX;
 704   stretchRangesX.PushBack( Uint16Pair( 2, 3 ) );
 705   StretchRanges stretchRangesY;
 706   stretchRangesY.PushBack( Uint16Pair( 4, 5 ) );
 707   Integration::ResourcePointer ninePatchResource = CustomizeNinePatch( application, ninePatchImageWidth, ninePatchImageHeight, stretchRangesX, stretchRangesY );
 708
 709   ControlRenderer controlRenderer = factory.GetControlRenderer( TEST_NPATCH_FILE_NAME );
 710   DALI_TEST_CHECK( controlRenderer );
 711
 712   Actor actor = Actor::New();
 713   TestControlRendererRender( application, actor, controlRenderer, 1u,
 714                              ImageDimensions(ninePatchImageWidth, ninePatchImageHeight),
 715                              ninePatchResource );
 716
 717   TestGlAbstraction& gl = application.GetGlAbstraction();
 718   int textureUnit = -1;
 719   DALI_TEST_CHECK( gl.GetUniformValue< int >( "sTexture", textureUnit ) );
 720   DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
 721
 722   END_TEST;
 723 }
 724
 725 int UtcDaliRendererFactoryGetNPatchRenderer4(void)
 726 {
 727   ToolkitTestApplication application;
 728   tet_infoline( "UtcDaliRendererFactoryGetNPatchRenderer4: Request n-patch renderer with an image url" );
 729
 730   RendererFactory factory = RendererFactory::Get();
 731   DALI_TEST_CHECK( factory );
 732
 733   const unsigned int ninePatchImageHeight = 18;
 734   const unsigned int ninePatchImageWidth = 28;
 735   StretchRanges stretchRangesX;
 736   stretchRangesX.PushBack( Uint16Pair( 2, 3 ) );
 737   stretchRangesX.PushBack( Uint16Pair( 5, 7 ) );
 738   stretchRangesX.PushBack( Uint16Pair( 12, 15 ) );
 739   StretchRanges stretchRangesY;
 740   stretchRangesY.PushBack( Uint16Pair( 4, 5 ) );
 741   stretchRangesY.PushBack( Uint16Pair( 8, 12 ) );
 742   stretchRangesY.PushBack( Uint16Pair( 15, 16 ) );
 743   stretchRangesY.PushBack( Uint16Pair( 25, 27 ) );
 744   Integration::ResourcePointer ninePatchResource = CustomizeNinePatch( application, ninePatchImageWidth, ninePatchImageHeight, stretchRangesX, stretchRangesY );
 745
 746   ControlRenderer controlRenderer = factory.GetControlRenderer( TEST_NPATCH_FILE_NAME );
 747   DALI_TEST_CHECK( controlRenderer );
 748
 749   Actor actor = Actor::New();
 750   TestControlRendererRender( application, actor, controlRenderer, 1u,
 751                              ImageDimensions(ninePatchImageWidth, ninePatchImageHeight),
 752                              ninePatchResource );
 753
 754   TestGlAbstraction& gl = application.GetGlAbstraction();
 755   int textureUnit = -1;
 756   DALI_TEST_CHECK( gl.GetUniformValue< int >( "sTexture", textureUnit ) );
 757   DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
 758
 759   END_TEST;
 760 }
 761
 762 int UtcDaliRendererFactoryGetNPatchRendererN1(void)
 763 {
 764   //This should still load but display an error image
 765
 766   ToolkitTestApplication application;
 767   tet_infoline( "UtcDaliRendererFactoryGetNPatchRendererN: Request n-patch renderer with an invalid image url" );
 768
 769   RendererFactory factory = RendererFactory::Get();
 770   DALI_TEST_CHECK( factory );
 771
 772   ControlRenderer controlRenderer = factory.GetControlRenderer( "ERROR.9.jpg" );
 773   DALI_TEST_CHECK( controlRenderer );
 774
 775   Actor actor = Actor::New();
 776   //The testkit still has to load a bitmap for the broken renderer image
 777   TestControlRendererRender( application, actor, controlRenderer, 1u,
 778                              ImageDimensions(),
 779                              Integration::ResourcePointer(Integration::Bitmap::New(Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD)) );
 780
 781   TestGlAbstraction& gl = application.GetGlAbstraction();
 782   int textureUnit = -1;
 783   DALI_TEST_CHECK( gl.GetUniformValue< int >( "sTexture", textureUnit ) );
 784   DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
 785
 786   END_TEST;
 787 }
 788
 789 int UtcDaliRendererFactoryGetNPatchRendererN2(void)
 790 {
 791   //This should still load but display an error image
 792
 793   ToolkitTestApplication application;
 794   tet_infoline( "UtcDaliRendererFactoryGetNPatchRendererN: Request n-patch renderer with an invalid Property::Map" );
 795
 796   RendererFactory factory = RendererFactory::Get();
 797   DALI_TEST_CHECK( factory );
 798
 799   Property::Map propertyMap;
 800   propertyMap.Insert( "rendererType",  "nPatchRenderer" );
 801   propertyMap.Insert( "imageUrl",  111 );
 802
 803   ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
 804   DALI_TEST_CHECK( controlRenderer );
 805
 806   Actor actor = Actor::New();
 807   //The testkit still has to load a bitmap for the broken renderer image
 808   TestControlRendererRender( application, actor, controlRenderer, 1u,
 809                              ImageDimensions(),
 810                              Integration::ResourcePointer(Integration::Bitmap::New(Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD)) );
 811
 812   TestGlAbstraction& gl = application.GetGlAbstraction();
 813   int textureUnit = -1;
 814   DALI_TEST_CHECK( gl.GetUniformValue< int >( "sTexture", textureUnit ) );
 815   DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
 816
 817   END_TEST;
 818 }
 819
 820 int UtcDaliRendererFactoryResetRenderer1(void)
 821 {
 822   ToolkitTestApplication application;
 823   tet_infoline( "UtcDaliRendererFactoryResetRenderer1" );
 824
 825   RendererFactory factory = RendererFactory::Get();
 826   DALI_TEST_CHECK( factory );
 827
 828   ControlRenderer controlRenderer = factory.GetControlRenderer( Color::RED );
 829   DALI_TEST_CHECK( controlRenderer );
 830
 831   Actor actor = Actor::New();
 832   TestControlRendererRender( application, actor, controlRenderer );
 833
 834   Vector4 actualValue(Vector4::ZERO);
 835   TestGlAbstraction& gl = application.GetGlAbstraction();
 836   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "blendColor", actualValue ) );
 837   DALI_TEST_EQUALS( actualValue, Color::RED, TEST_LOCATION );
 838
 839   factory.ResetRenderer( controlRenderer, actor, Color::GREEN );
 840   application.SendNotification();
 841   application.Render(0);
 842   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "blendColor", actualValue ) );
 843   DALI_TEST_EQUALS( actualValue, Color::GREEN, TEST_LOCATION );
 844
 845   Image bufferImage = CreateBufferImage( 100, 200, Vector4( 1.f, 1.f, 1.f, 1.f ) );
 846   factory.ResetRenderer( controlRenderer, actor, bufferImage );
 847
 848   Actor actor2 = Actor::New();
 849   actor2.SetSize(200.f, 200.f);
 850   Stage::GetCurrent().Add( actor2 );
 851   controlRenderer.SetSize(Vector2(200.f, 200.f));
 852   controlRenderer.SetOnStage( actor2 );
 853   application.SendNotification();
 854   application.Render(0);
 855
 856   END_TEST;
 857 }
 858
 859 int UtcDaliRendererFactoryResetRenderer2(void)
 860 {
 861   ToolkitTestApplication application;
 862   tet_infoline( "UtcDaliRendererFactoryResetRenderer2" );
 863
 864   Actor actor = Actor::New();
 865   actor.SetSize(200.f, 200.f);
 866   Stage::GetCurrent().Add( actor );
 867   RendererFactory factory = RendererFactory::Get();
 868   DALI_TEST_CHECK( factory );
 869
 870   Image resourceImage = ResourceImage::New(TEST_IMAGE_FILE_NAME);
 871   ControlRenderer controlRenderer = factory.GetControlRenderer( resourceImage );
 872   DALI_TEST_CHECK( controlRenderer );
 873   controlRenderer.SetSize(Vector2(200.f, 200.f));
 874   controlRenderer.SetOnStage( actor );
 875   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 876
 877   application.SendNotification();
 878   application.Render(0);
 879
 880   Image bufferImage = CreateBufferImage( 100, 200, Vector4( 1.f, 1.f, 1.f, 1.f ) );
 881   factory.ResetRenderer( controlRenderer, actor, bufferImage );
 882   application.SendNotification();
 883   application.Render(0);
 884
 885   factory.ResetRenderer( controlRenderer, actor, Color::RED );
 886
 887   Actor actor2 = Actor::New();
 888   actor2.SetSize(200.f, 200.f);
 889   Stage::GetCurrent().Add( actor2 );
 890   controlRenderer.SetSize(Vector2(200.f, 200.f));
 891   controlRenderer.SetOnStage( actor2 );
 892   TestGlAbstraction& gl = application.GetGlAbstraction();
 893   application.SendNotification();
 894   application.Render(0);
 895   Vector4 actualValue(Vector4::ZERO);
 896   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "blendColor", actualValue ) );
 897   DALI_TEST_EQUALS( actualValue, Color::RED, TEST_LOCATION );
 898
 899   END_TEST;
 900 }