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 <toolkit-event-thread-callback.h>
  21 #include <dali/devel-api/rendering/renderer.h>
  22 #include <dali/devel-api/rendering/texture-set.h>
  23 #include <dali/devel-api/rendering/shader.h>
  24 #include <dali-toolkit/devel-api/controls/renderer-factory/renderer-factory.h>
  25
  26 using namespace Dali;
  27 using namespace Dali::Toolkit;
  28
  29 namespace
  30 {
  31 typedef NinePatchImage::StretchRanges StretchRanges;
  32
  33 const char* TEST_IMAGE_FILE_NAME =  "gallery_image_01.jpg";
  34 const char* TEST_NPATCH_FILE_NAME =  "gallery_image_01.9.jpg";
  35 const char* TEST_SVG_FILE_NAME = TEST_RESOURCE_DIR "/svg1.svg";
  36 const char* TEST_OBJ_FILE_NAME = TEST_RESOURCE_DIR "/Cube.obj";
  37 const char* TEST_MTL_FILE_NAME = TEST_RESOURCE_DIR "/ToyRobot-Metal.mtl";
  38 const char* TEST_SIMPLE_MTL_FILE_NAME = TEST_RESOURCE_DIR "/ToyRobot-Metal-Simple.mtl";
  39
  40 Integration::Bitmap* CreateBitmap( unsigned int imageWidth, unsigned int imageHeight, unsigned int initialColor, Pixel::Format pixelFormat )
  41 {
  42   Integration::Bitmap* bitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_RETAIN );
  43   Integration::PixelBuffer* pixbuffer = bitmap->GetPackedPixelsProfile()->ReserveBuffer( pixelFormat, imageWidth, imageHeight, imageWidth, imageHeight );
  44   unsigned int bytesPerPixel = GetBytesPerPixel( pixelFormat );
  45
  46   memset( pixbuffer, initialColor, imageHeight * imageWidth * bytesPerPixel );
  47
  48   return bitmap;
  49 }
  50
  51 void InitialiseRegionsToZeroAlpha( Integration::Bitmap* image, unsigned int imageWidth, unsigned int imageHeight, Pixel::Format pixelFormat )
  52 {
  53   PixelBuffer* pixbuffer = image->GetBuffer();
  54   unsigned int bytesPerPixel = GetBytesPerPixel( pixelFormat );
  55
  56   for( unsigned int row = 0; row < imageWidth; ++row )
  57   {
  58     unsigned int pixelOffset = row * bytesPerPixel;
  59     pixbuffer[ pixelOffset + 3 ] = 0x00;
  60     pixelOffset += ( imageHeight - 1 ) * imageWidth * bytesPerPixel;
  61     pixbuffer[ pixelOffset + 3 ] = 0x00;
  62   }
  63
  64   for ( unsigned int column = 0; column < imageHeight; ++column )
  65   {
  66     unsigned int pixelOffset = column * imageWidth * bytesPerPixel;
  67     pixbuffer[ pixelOffset + 3 ] = 0x00;
  68     pixelOffset += ( imageWidth -1 ) * bytesPerPixel;
  69     pixbuffer[ pixelOffset + 3 ] = 0x00;
  70   }
  71 }
  72
  73 void AddStretchRegionsToImage( Integration::Bitmap* image, unsigned int imageWidth, unsigned int imageHeight, const StretchRanges& stretchRangesX, const StretchRanges& stretchRangesY, Pixel::Format pixelFormat )
  74 {
  75   PixelBuffer* pixbuffer = image->GetBuffer();
  76   unsigned int bytesPerPixel = GetBytesPerPixel( pixelFormat );
  77
  78   for(StretchRanges::ConstIterator it = stretchRangesX.Begin(); it != stretchRangesX.End(); ++it)
  79   {
  80     const Uint16Pair& range = *it;
  81     //since the stretch range is in the cropped image space, we need to offset by 1 to get it to the uncropped image space
  82     for( unsigned int column = range.GetX() + 1u; column < range.GetY() + 1u; ++column )
  83     {
  84       unsigned int pixelOffset = column * bytesPerPixel;
  85       pixbuffer[ pixelOffset ] = 0x00;
  86       pixbuffer[ pixelOffset + 1 ] = 0x00;
  87       pixbuffer[ pixelOffset + 2 ] = 0x00;
  88       pixbuffer[ pixelOffset + 3 ] = 0xFF;
  89     }
  90   }
  91
  92
  93   for(StretchRanges::ConstIterator it = stretchRangesY.Begin(); it != stretchRangesY.End(); ++it)
  94   {
  95     const Uint16Pair& range = *it;
  96     //since the stretch range is in the cropped image space, we need to offset by 1 to get it to the uncropped image space
  97     for( unsigned int row = range.GetX() + 1u; row < range.GetY() + 1u; ++row )
  98     {
  99       unsigned int pixelOffset = row * imageWidth * bytesPerPixel;
 100       pixbuffer[ pixelOffset ] = 0x00;
 101       pixbuffer[ pixelOffset + 1 ] = 0x00;
 102       pixbuffer[ pixelOffset + 2 ] = 0x00;
 103       pixbuffer[ pixelOffset + 3 ] = 0xFF;
 104     }
 105   }
 106 }
 107
 108 void AddChildRegionsToImage( Integration::Bitmap* image, unsigned int imageWidth, unsigned int imageHeight, const Vector4& requiredChildRegion, Pixel::Format pixelFormat )
 109 {
 110   PixelBuffer* pixbuffer = image->GetBuffer();
 111   unsigned int bytesPerPixel = GetBytesPerPixel( pixelFormat );
 112
 113   Integration::Bitmap::PackedPixelsProfile* srcProfile = image->GetPackedPixelsProfile();
 114   unsigned int bufferStride = srcProfile->GetBufferStride();
 115
 116   // Add bottom child region
 117   for( unsigned int column = requiredChildRegion.x; column < imageWidth - requiredChildRegion.z; ++column )
 118   {
 119     unsigned int pixelOffset = column * bytesPerPixel;
 120     pixelOffset += ( imageHeight - 1 ) * bufferStride;
 121     pixbuffer[ pixelOffset ] = 0x00;
 122     pixbuffer[ pixelOffset + 1 ] = 0x00;
 123     pixbuffer[ pixelOffset + 2 ] = 0x00;
 124     pixbuffer[ pixelOffset + 3 ] = 0xFF;
 125   }
 126
 127   // Add right child region
 128   for ( unsigned int row = requiredChildRegion.y; row < imageHeight - requiredChildRegion.w; ++row )
 129   {
 130     unsigned int pixelOffset = row * bufferStride + ( imageWidth - 1 ) * bytesPerPixel;
 131     pixbuffer[ pixelOffset ] = 0x00;
 132     pixbuffer[ pixelOffset + 1 ] = 0x00;
 133     pixbuffer[ pixelOffset + 2 ] = 0x00;
 134     pixbuffer[ pixelOffset + 3 ] = 0xFF;
 135   }
 136 }
 137
 138 Integration::ResourcePointer CustomizeNinePatch( TestApplication& application,
 139                                                  unsigned int ninePatchImageWidth,
 140                                                  unsigned int ninePatchImageHeight,
 141                                                  const StretchRanges& stretchRangesX,
 142                                                  const StretchRanges& stretchRangesY,
 143                                                  bool addChildRegion = false,
 144                                                  Vector4 requiredChildRegion = Vector4::ZERO )
 145 {
 146   TestPlatformAbstraction& platform = application.GetPlatform();
 147
 148   Pixel::Format pixelFormat = Pixel::RGBA8888;
 149
 150   tet_infoline("Create Bitmap");
 151   platform.SetClosestImageSize(Vector2( ninePatchImageWidth, ninePatchImageHeight));
 152   Integration::Bitmap* bitmap = CreateBitmap( ninePatchImageWidth, ninePatchImageHeight, 0xFF, pixelFormat );
 153
 154   tet_infoline("Clear border regions");
 155   InitialiseRegionsToZeroAlpha( bitmap, ninePatchImageWidth, ninePatchImageHeight, pixelFormat );
 156
 157   tet_infoline("Add Stretch regions to Bitmap");
 158   AddStretchRegionsToImage( bitmap, ninePatchImageWidth, ninePatchImageHeight, stretchRangesX, stretchRangesY, pixelFormat );
 159
 160   if( addChildRegion )
 161   {
 162     tet_infoline("Add Child regions to Bitmap");
 163     AddChildRegionsToImage( bitmap, ninePatchImageWidth, ninePatchImageHeight, requiredChildRegion, pixelFormat );
 164   }
 165
 166   tet_infoline("Getting resource");
 167   Integration::ResourcePointer resourcePtr(bitmap);
 168   platform.SetResourceLoaded( 0, Dali::Integration::ResourceBitmap, resourcePtr );
 169
 170   return resourcePtr;
 171 }
 172
 173 void TestControlRendererRender( ToolkitTestApplication& application,
 174                                 Actor& actor,
 175                                 ControlRenderer& controlRenderer,
 176                                 std::size_t expectedSamplers = 0,
 177                                 ImageDimensions imageDimensions = ImageDimensions(),
 178                                 Integration::ResourcePointer resourcePtr = Integration::ResourcePointer())
 179 {
 180   if( resourcePtr )
 181   {
 182     // set the image size, for test case, this needs to be set before loading started
 183     application.GetPlatform().SetClosestImageSize(  Vector2(imageDimensions.GetWidth(), imageDimensions.GetHeight()) );
 184   }
 185
 186   actor.SetSize( 200.f, 200.f );
 187   Stage::GetCurrent().Add( actor );
 188   controlRenderer.SetSize( Vector2(200.f, 200.f) );
 189   controlRenderer.SetOnStage( actor );
 190
 191   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 192
 193   application.SendNotification();
 194   application.Render();
 195
 196   if( resourcePtr )
 197   {
 198     Integration::ResourceRequest* request = application.GetPlatform().GetRequest();
 199     if(request)
 200     {
 201       application.GetPlatform().SetResourceLoaded(request->GetId(), request->GetType()->id, resourcePtr );
 202     }
 203   }
 204
 205   application.Render();
 206   application.SendNotification();
 207
 208   if( resourcePtr )
 209   {
 210     DALI_TEST_CHECK( application.GetPlatform().WasCalled(TestPlatformAbstraction::LoadResourceFunc) ||
 211                      application.GetPlatform().WasCalled(TestPlatformAbstraction::LoadResourceSynchronouslyFunc ));
 212   }
 213
 214   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 215
 216 }
 217
 218 } // namespace
 219
 220
 221 void dali_renderer_factory_startup(void)
 222 {
 223   test_return_value = TET_UNDEF;
 224 }
 225
 226 void dali_renderer_factory_cleanup(void)
 227 {
 228   test_return_value = TET_PASS;
 229 }
 230
 231 int UtcDaliRendererFactoryGet(void)
 232 {
 233   ToolkitTestApplication application;
 234   tet_infoline( "UtcDaliRendererFactory" );
 235
 236   //Register type
 237   TypeInfo type;
 238   type = TypeRegistry::Get().GetTypeInfo( "RendererFactory" );
 239   DALI_TEST_CHECK( type );
 240   BaseHandle handle = type.CreateInstance();
 241   DALI_TEST_CHECK( handle );
 242
 243   RendererFactory factory;
 244   factory = RendererFactory::Get();
 245   DALI_TEST_CHECK( factory );
 246
 247   RendererFactory newFactory = RendererFactory::Get();
 248   DALI_TEST_CHECK( newFactory );
 249
 250   // Check that renderer factory is a singleton
 251   DALI_TEST_CHECK(factory == newFactory);
 252
 253   END_TEST;
 254 }
 255
 256 int UtcDaliRendererFactoryCopyAndAssignment(void)
 257 {
 258   ToolkitTestApplication application;
 259   tet_infoline( "UtcDaliRendererFactoryCopyAndAssignment" );
 260   RendererFactory factory = RendererFactory::Get();
 261
 262   RendererFactory factoryCopy( factory );
 263   DALI_TEST_CHECK(factory == factoryCopy);
 264
 265   RendererFactory emptyFactory;
 266   RendererFactory emptyFactoryCopy( emptyFactory );
 267   DALI_TEST_CHECK(emptyFactory == emptyFactoryCopy);
 268
 269   RendererFactory factoryEquals;
 270   factoryEquals = factory;
 271   DALI_TEST_CHECK(factory == factoryEquals);
 272
 273   RendererFactory emptyFactoryEquals;
 274   emptyFactoryEquals = emptyFactory;
 275   DALI_TEST_CHECK( emptyFactory == emptyFactoryEquals );
 276
 277   //self assignment
 278   factory = factory;
 279   DALI_TEST_CHECK( factory = factoryCopy );
 280
 281   END_TEST;
 282 }
 283
 284 int UtcDaliRendererFactoryGetColorRenderer1(void)
 285 {
 286   ToolkitTestApplication application;
 287   tet_infoline( "UtcDaliRendererFactoryGetColorRenderer1:  Request color renderer with a Property::Map" );
 288
 289   RendererFactory factory = RendererFactory::Get();
 290   DALI_TEST_CHECK( factory );
 291
 292   Property::Map propertyMap;
 293   Vector4 testColor( 1.f, 0.5f, 0.3f, 0.2f );
 294   propertyMap.Insert("rendererType",  "color");
 295   propertyMap.Insert("mixColor",  testColor);
 296
 297   ControlRenderer controlRenderer = factory.GetControlRenderer(propertyMap);
 298   DALI_TEST_CHECK( controlRenderer );
 299
 300   Actor actor = Actor::New();
 301   TestControlRendererRender( application, actor, controlRenderer );
 302
 303   Vector4 actualValue(Vector4::ZERO);
 304   TestGlAbstraction& gl = application.GetGlAbstraction();
 305   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "mixColor", actualValue ) );
 306   DALI_TEST_EQUALS( actualValue, testColor, TEST_LOCATION );
 307
 308   END_TEST;
 309 }
 310
 311 int UtcDaliRendererFactoryGetColorRenderer2(void)
 312 {
 313   ToolkitTestApplication application;
 314   tet_infoline( "UtcDaliRendererFactoryGetColorRenderer2: Request color renderer with a Vector4" );
 315
 316   RendererFactory factory = RendererFactory::Get();
 317   DALI_TEST_CHECK( factory );
 318
 319   Vector4 testColor( 1.f, 0.5f, 0.3f, 0.2f );
 320   ControlRenderer controlRenderer = factory.GetControlRenderer(testColor);
 321   DALI_TEST_CHECK( controlRenderer );
 322
 323   Actor actor = Actor::New();
 324   TestControlRendererRender( application, actor, controlRenderer );
 325
 326   Vector4 actualValue(Vector4::ZERO);
 327   TestGlAbstraction& gl = application.GetGlAbstraction();
 328   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "mixColor", actualValue ) );
 329   DALI_TEST_EQUALS( actualValue, testColor, TEST_LOCATION );
 330
 331   controlRenderer.SetOffStage( actor );
 332   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 333
 334   END_TEST;
 335 }
 336
 337 int UtcDaliRendererFactoryGetBorderRenderer1(void)
 338 {
 339   ToolkitTestApplication application;
 340   tet_infoline( "UtcDaliRendererFactoryGetBorderRenderer1:  Request border renderer with a Property::Map" );
 341
 342   RendererFactory factory = RendererFactory::Get();
 343   DALI_TEST_CHECK( factory );
 344
 345   Property::Map propertyMap;
 346   Vector4 testColor( 1.f, 0.5f, 0.3f, 0.2f );
 347   float testSize = 5.f;
 348   propertyMap.Insert("rendererType",  "border");
 349   propertyMap.Insert("borderColor",  testColor);
 350   propertyMap.Insert("borderSize",  testSize);
 351
 352   ControlRenderer controlRenderer = factory.GetControlRenderer(propertyMap);
 353   DALI_TEST_CHECK( controlRenderer );
 354
 355   Actor actor = Actor::New();
 356   actor.SetSize(200.f, 200.f);
 357   Stage::GetCurrent().Add( actor );
 358   controlRenderer.SetSize(Vector2(200.f, 200.f));
 359   controlRenderer.SetOnStage( actor );
 360
 361   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 362   int blendMode = actor.GetRendererAt(0u).GetProperty<int>( Renderer::Property::BLEND_MODE );
 363   DALI_TEST_EQUALS( static_cast<BlendingMode::Type>(blendMode), BlendingMode::ON, TEST_LOCATION );
 364
 365   TestGlAbstraction& gl = application.GetGlAbstraction();
 366
 367   application.SendNotification();
 368   application.Render(0);
 369
 370   Vector4 actualColor(Vector4::ZERO);
 371   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "borderColor", actualColor ) );
 372   DALI_TEST_EQUALS( actualColor, testColor, TEST_LOCATION );
 373
 374   float actualSize = 0.f;
 375   DALI_TEST_CHECK( gl.GetUniformValue<float>( "borderSize", actualSize ) );
 376   DALI_TEST_EQUALS( actualSize, testSize, TEST_LOCATION );
 377
 378   controlRenderer.SetOffStage( actor );
 379   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 380
 381   END_TEST;
 382 }
 383
 384 int UtcDaliRendererFactoryGetBorderRenderer2(void)
 385 {
 386   ToolkitTestApplication application;
 387   tet_infoline( "UtcDaliRendererFactoryGetBorderRenderer2:  Request border renderer with a borderSize and a borderColor" );
 388
 389   RendererFactory factory = RendererFactory::Get();
 390   DALI_TEST_CHECK( factory );
 391
 392   Vector4 testColor( 1.f, 0.5f, 0.3f, 1.f );
 393   float testSize = 5.f;
 394
 395   ControlRenderer controlRenderer = factory.GetControlRenderer(testSize, testColor );
 396   DALI_TEST_CHECK( controlRenderer );
 397
 398   Actor actor = Actor::New();
 399   actor.SetSize(200.f, 200.f);
 400   Stage::GetCurrent().Add( actor );
 401   controlRenderer.SetSize(Vector2(200.f, 200.f));
 402   controlRenderer.SetOnStage( actor );
 403
 404   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 405
 406   TestGlAbstraction& gl = application.GetGlAbstraction();
 407
 408   application.SendNotification();
 409   application.Render(0);
 410
 411   int blendMode = actor.GetRendererAt(0u).GetProperty<int>( Renderer::Property::BLEND_MODE );
 412   DALI_TEST_EQUALS( static_cast<BlendingMode::Type>(blendMode), BlendingMode::AUTO, TEST_LOCATION );
 413
 414   Vector4 actualColor(Vector4::ZERO);
 415   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "borderColor", actualColor ) );
 416   DALI_TEST_EQUALS( actualColor, testColor, TEST_LOCATION );
 417
 418   float actualSize = 0.f;
 419   DALI_TEST_CHECK( gl.GetUniformValue<float>( "borderSize", actualSize ) );
 420   DALI_TEST_EQUALS( actualSize, testSize, TEST_LOCATION );
 421
 422   controlRenderer.SetOffStage( actor );
 423
 424   // enable the anti-aliasing
 425   controlRenderer = factory.GetControlRenderer(testSize, testColor, true );
 426   controlRenderer.SetOnStage( actor );
 427
 428   application.SendNotification();
 429   application.Render(0);
 430   blendMode = actor.GetRendererAt(0u).GetProperty<int>( Renderer::Property::BLEND_MODE );
 431   DALI_TEST_EQUALS( static_cast<BlendingMode::Type>(blendMode), BlendingMode::ON, TEST_LOCATION );
 432
 433   END_TEST;
 434 }
 435
 436 int UtcDaliRendererFactoryGetLinearGradientRenderer(void)
 437 {
 438   ToolkitTestApplication application;
 439   tet_infoline("UtcDaliRendererFactoryGetRadialGradientRenderer");
 440
 441   RendererFactory factory = RendererFactory::Get();
 442   DALI_TEST_CHECK( factory );
 443
 444   Property::Map propertyMap;
 445   propertyMap.Insert("rendererType",  "gradient");
 446
 447   Vector2 start(-1.f, -1.f);
 448   Vector2 end(1.f, 1.f);
 449   propertyMap.Insert("startPosition",   start);
 450   propertyMap.Insert("endPosition",   end);
 451   propertyMap.Insert("spreadMethod",   "repeat");
 452
 453   Property::Array stopOffsets;
 454   stopOffsets.PushBack( 0.2f );
 455   stopOffsets.PushBack( 0.8f );
 456   propertyMap.Insert("stopOffset",   stopOffsets);
 457
 458   Property::Array stopColors;
 459   stopColors.PushBack( Color::RED );
 460   stopColors.PushBack( Color::GREEN );
 461   propertyMap.Insert("stopColor",   stopColors);
 462
 463   ControlRenderer controlRenderer = factory.GetControlRenderer(propertyMap);
 464   DALI_TEST_CHECK( controlRenderer );
 465
 466   // A lookup texture is generated and pass to shader as sampler
 467   Actor actor = Actor::New();
 468   TestControlRendererRender( application, actor, controlRenderer, 1u );
 469
 470   controlRenderer.SetOffStage( actor );
 471   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 472
 473   END_TEST;
 474 }
 475
 476 int UtcDaliRendererFactoryGetRadialGradientRenderer(void)
 477 {
 478   ToolkitTestApplication application;
 479   tet_infoline("UtcDaliRendererFactoryGetRadialGradientRenderer");
 480
 481   RendererFactory factory = RendererFactory::Get();
 482   DALI_TEST_CHECK( factory );
 483
 484   Property::Map propertyMap;
 485   propertyMap.Insert("rendererType",  "gradient");
 486
 487   Vector2 center(100.f, 100.f);
 488   float radius = 100.f;
 489   propertyMap.Insert("units",  "userSpace");
 490   propertyMap.Insert("center",  center);
 491   propertyMap.Insert("radius",  radius);
 492
 493   Property::Array stopOffsets;
 494   stopOffsets.PushBack( 0.0f );
 495   stopOffsets.PushBack( 1.f );
 496   propertyMap.Insert("stopOffset",   stopOffsets);
 497
 498   Property::Array stopColors;
 499   stopColors.PushBack( Color::RED );
 500   stopColors.PushBack( Color::GREEN );
 501   propertyMap.Insert("stopColor",   stopColors);
 502
 503   ControlRenderer controlRenderer = factory.GetControlRenderer(propertyMap);
 504   DALI_TEST_CHECK( controlRenderer );
 505
 506   // A lookup texture is generated and pass to shader as sampler
 507   Actor actor = Actor::New();
 508   TestControlRendererRender( application, actor, controlRenderer, 1u );
 509
 510   Matrix3 alignMatrix( radius, 0.f, 0.f, 0.f, radius, 0.f, center.x, center.y, 1.f );
 511   alignMatrix.Invert();
 512
 513   Matrix3 actualValue( Matrix3::IDENTITY );
 514   TestGlAbstraction& gl = application.GetGlAbstraction();
 515   DALI_TEST_CHECK( gl.GetUniformValue<Matrix3>( "uAlignmentMatrix", actualValue ) );
 516   DALI_TEST_EQUALS( actualValue, alignMatrix, Math::MACHINE_EPSILON_100, TEST_LOCATION );
 517
 518   END_TEST;
 519 }
 520
 521 int UtcDaliRendererFactoryDefaultOffsetsGradientRenderer(void)
 522 {
 523   ToolkitTestApplication application;
 524   tet_infoline("UtcDaliRendererFactoryGetRadialGradientRenderer");
 525
 526   RendererFactory factory = RendererFactory::Get();
 527   DALI_TEST_CHECK( factory );
 528
 529   Property::Map propertyMap;
 530   propertyMap.Insert("rendererType",  "gradient");
 531
 532   Vector2 start(-1.f, -1.f);
 533   Vector2 end(1.f, 1.f);
 534   propertyMap.Insert("startPosition",   start);
 535   propertyMap.Insert("endPosition",   end);
 536   propertyMap.Insert("spreadMethod",   "repeat");
 537
 538   Property::Array stopColors;
 539   stopColors.PushBack( Color::RED );
 540   stopColors.PushBack( Color::GREEN );
 541   propertyMap.Insert("stopColor",   stopColors);
 542
 543   ControlRenderer controlRenderer = factory.GetControlRenderer(propertyMap);
 544   DALI_TEST_CHECK( controlRenderer );
 545
 546   // A lookup texture is generated and pass to shader as sampler
 547   Actor actor = Actor::New();
 548   TestControlRendererRender( application, actor, controlRenderer, 1u );
 549
 550   controlRenderer.SetOffStage( actor );
 551   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 552
 553   END_TEST;
 554 }
 555
 556 int UtcDaliRendererFactoryGetImageRenderer1(void)
 557 {
 558   ToolkitTestApplication application;
 559   tet_infoline( "UtcDaliRendererFactoryGetImageRenderer1: Request image renderer with a Property::Map" );
 560
 561   RendererFactory factory = RendererFactory::Get();
 562   DALI_TEST_CHECK( factory );
 563
 564   Property::Map propertyMap;
 565   propertyMap.Insert( "rendererType",  "image" );
 566   propertyMap.Insert( "url",  TEST_IMAGE_FILE_NAME );
 567
 568   ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
 569   DALI_TEST_CHECK( controlRenderer );
 570
 571   Actor actor = Actor::New();
 572   // For tesing the LoadResourceFunc is called, a big image size should be set, so the atlasing is not applied.
 573   // Image with a size smaller than 512*512 will be uploaded as a part of the atlas.
 574
 575   const int width=512;
 576   const int height=513;
 577   TestGlAbstraction& gl = application.GetGlAbstraction();
 578   TraceCallStack& textureTrace = gl.GetTextureTrace();
 579   textureTrace.Enable(true);
 580
 581   Integration::Bitmap* bitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD );
 582   bitmap->GetPackedPixelsProfile()->ReserveBuffer( Pixel::RGBA8888, width, height,width, height );
 583
 584   TestControlRendererRender( application, actor, controlRenderer, 1u,
 585                              ImageDimensions(width, height),
 586                              Integration::ResourcePointer( bitmap ) );
 587
 588   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 589
 590   controlRenderer.SetOffStage( actor );
 591   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 592
 593   END_TEST;
 594 }
 595
 596 int UtcDaliRendererFactoryGetImageRenderer2(void)
 597 {
 598   ToolkitTestApplication application;
 599   tet_infoline( "UtcDaliRendererFactoryGetImageRenderer2: Request image renderer with an image handle" );
 600
 601   RendererFactory factory = RendererFactory::Get();
 602   DALI_TEST_CHECK( factory );
 603
 604   Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME);
 605   ControlRenderer controlRenderer = factory.GetControlRenderer( image );
 606
 607   Actor actor = Actor::New();
 608   // For tesing the LoadResourceFunc is called, a big image size should be set, so the atlasing is not applied.
 609   // Image with a size smaller than 512*512 will be uploaded as a part of the atlas.
 610
 611   const int width=512;
 612   const int height=513;
 613
 614   Integration::Bitmap* bitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD );
 615   bitmap->GetPackedPixelsProfile()->ReserveBuffer( Pixel::RGBA8888, width, height,width, height );
 616
 617   TestGlAbstraction& gl = application.GetGlAbstraction();
 618   TraceCallStack& textureTrace = gl.GetTextureTrace();
 619   textureTrace.Enable(true);
 620
 621   TestControlRendererRender( application, actor, controlRenderer, 1u,
 622                              ImageDimensions(width, height),
 623                              Integration::ResourcePointer(bitmap) );
 624
 625   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 626
 627   END_TEST;
 628 }
 629
 630 int UtcDaliRendererFactoryGetNPatchRenderer1(void)
 631 {
 632   ToolkitTestApplication application;
 633   tet_infoline( "UtcDaliRendererFactoryGetNPatchRenderer1: Request 9-patch renderer with a Property::Map" );
 634
 635   RendererFactory factory = RendererFactory::Get();
 636   DALI_TEST_CHECK( factory );
 637
 638   const unsigned int ninePatchImageHeight = 18;
 639   const unsigned int ninePatchImageWidth = 28;
 640   StretchRanges stretchRangesX;
 641   stretchRangesX.PushBack( Uint16Pair( 2, 3 ) );
 642   StretchRanges stretchRangesY;
 643   stretchRangesY.PushBack( Uint16Pair( 4, 5 ) );
 644   Integration::ResourcePointer ninePatchResource = CustomizeNinePatch( application, ninePatchImageWidth, ninePatchImageHeight, stretchRangesX, stretchRangesY );
 645
 646   Property::Map propertyMap;
 647   propertyMap.Insert( "rendererType",  "image" );
 648   propertyMap.Insert( "url",  TEST_NPATCH_FILE_NAME );
 649   {
 650     tet_infoline( "whole grid" );
 651     ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
 652     DALI_TEST_CHECK( controlRenderer );
 653
 654     Actor actor = Actor::New();
 655
 656     TestGlAbstraction& gl = application.GetGlAbstraction();
 657     TraceCallStack& textureTrace = gl.GetTextureTrace();
 658     textureTrace.Enable(true);
 659
 660     TestControlRendererRender( application, actor, controlRenderer, 1u,
 661                                ImageDimensions(ninePatchImageWidth, ninePatchImageHeight),
 662                                ninePatchResource );
 663
 664     DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 665   }
 666
 667   propertyMap.Insert( "borderOnly",  true );
 668   {
 669     tet_infoline( "border only" );
 670     ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
 671     DALI_TEST_CHECK( controlRenderer );
 672
 673     Actor actor = Actor::New();
 674
 675     TestGlAbstraction& gl = application.GetGlAbstraction();
 676     TraceCallStack& textureTrace = gl.GetTextureTrace();
 677     textureTrace.Enable(true);
 678
 679     TestControlRendererRender( application, actor, controlRenderer, 1u,
 680                                ImageDimensions(ninePatchImageWidth, ninePatchImageHeight),
 681                                ninePatchResource );
 682
 683     DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 684   }
 685
 686   END_TEST;
 687 }
 688
 689 int UtcDaliRendererFactoryGetNPatchRenderer2(void)
 690 {
 691   ToolkitTestApplication application;
 692   tet_infoline( "UtcDaliRendererFactoryGetNPatchRenderer2: Request n-patch renderer with a Property::Map" );
 693
 694   RendererFactory factory = RendererFactory::Get();
 695   DALI_TEST_CHECK( factory );
 696
 697   const unsigned int ninePatchImageWidth = 18;
 698   const unsigned int ninePatchImageHeight = 28;
 699   StretchRanges stretchRangesX;
 700   stretchRangesX.PushBack( Uint16Pair( 2, 3 ) );
 701   stretchRangesX.PushBack( Uint16Pair( 5, 7 ) );
 702   stretchRangesX.PushBack( Uint16Pair( 12, 15 ) );
 703   StretchRanges stretchRangesY;
 704   stretchRangesY.PushBack( Uint16Pair( 4, 5 ) );
 705   stretchRangesY.PushBack( Uint16Pair( 8, 12 ) );
 706   stretchRangesY.PushBack( Uint16Pair( 15, 16 ) );
 707   stretchRangesY.PushBack( Uint16Pair( 25, 27 ) );
 708   Integration::ResourcePointer ninePatchResource = CustomizeNinePatch( application, ninePatchImageWidth, ninePatchImageHeight, stretchRangesX, stretchRangesY );
 709
 710   Property::Map propertyMap;
 711   propertyMap.Insert( "rendererType",  "image" );
 712   propertyMap.Insert( "url",  TEST_NPATCH_FILE_NAME );
 713   {
 714     ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
 715     DALI_TEST_CHECK( controlRenderer );
 716
 717     Actor actor = Actor::New();
 718     TestGlAbstraction& gl = application.GetGlAbstraction();
 719     TraceCallStack& textureTrace = gl.GetTextureTrace();
 720     textureTrace.Enable(true);
 721
 722     TestControlRendererRender( application, actor, controlRenderer, 1u,
 723                                ImageDimensions(ninePatchImageWidth, ninePatchImageHeight),
 724                                ninePatchResource );
 725
 726
 727     DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 728
 729     controlRenderer.SetOffStage( actor );
 730     DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 731   }
 732
 733   propertyMap.Insert( "borderOnly",  true );
 734   {
 735     tet_infoline( "border only" );
 736     ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
 737     DALI_TEST_CHECK( controlRenderer );
 738
 739     TestGlAbstraction& gl = application.GetGlAbstraction();
 740     TraceCallStack& textureTrace = gl.GetTextureTrace();
 741     textureTrace.Enable(true);
 742     Actor actor = Actor::New();
 743     TestControlRendererRender( application, actor, controlRenderer, 1u,
 744                                ImageDimensions(ninePatchImageWidth, ninePatchImageHeight),
 745                                ninePatchResource );
 746
 747
 748     DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 749
 750     controlRenderer.SetOffStage( actor );
 751     DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 752   }
 753
 754   END_TEST;
 755 }
 756
 757 int UtcDaliRendererFactoryGetNPatchRenderer3(void)
 758 {
 759   ToolkitTestApplication application;
 760   tet_infoline( "UtcDaliRendererFactoryGetNPatchRenderer3: Request 9-patch renderer with an image url" );
 761
 762   RendererFactory factory = RendererFactory::Get();
 763   DALI_TEST_CHECK( factory );
 764
 765   const unsigned int ninePatchImageHeight = 18;
 766   const unsigned int ninePatchImageWidth = 28;
 767   StretchRanges stretchRangesX;
 768   stretchRangesX.PushBack( Uint16Pair( 2, 3 ) );
 769   StretchRanges stretchRangesY;
 770   stretchRangesY.PushBack( Uint16Pair( 4, 5 ) );
 771   Integration::ResourcePointer ninePatchResource = CustomizeNinePatch( application, ninePatchImageWidth, ninePatchImageHeight, stretchRangesX, stretchRangesY );
 772
 773   ControlRenderer controlRenderer = factory.GetControlRenderer( TEST_NPATCH_FILE_NAME );
 774   DALI_TEST_CHECK( controlRenderer );
 775
 776   Actor actor = Actor::New();
 777
 778   TestGlAbstraction& gl = application.GetGlAbstraction();
 779   TraceCallStack& textureTrace = gl.GetTextureTrace();
 780   textureTrace.Enable(true);
 781
 782   TestControlRendererRender( application, actor, controlRenderer, 1u,
 783                              ImageDimensions(ninePatchImageWidth, ninePatchImageHeight),
 784                              ninePatchResource );
 785
 786   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 787
 788   END_TEST;
 789 }
 790
 791 int UtcDaliRendererFactoryGetNPatchRenderer4(void)
 792 {
 793   ToolkitTestApplication application;
 794   tet_infoline( "UtcDaliRendererFactoryGetNPatchRenderer4: Request n-patch renderer with an image url" );
 795
 796   RendererFactory factory = RendererFactory::Get();
 797   DALI_TEST_CHECK( factory );
 798
 799   const unsigned int ninePatchImageHeight = 18;
 800   const unsigned int ninePatchImageWidth = 28;
 801   StretchRanges stretchRangesX;
 802   stretchRangesX.PushBack( Uint16Pair( 2, 3 ) );
 803   stretchRangesX.PushBack( Uint16Pair( 5, 7 ) );
 804   stretchRangesX.PushBack( Uint16Pair( 12, 15 ) );
 805   StretchRanges stretchRangesY;
 806   stretchRangesY.PushBack( Uint16Pair( 4, 5 ) );
 807   stretchRangesY.PushBack( Uint16Pair( 8, 12 ) );
 808   stretchRangesY.PushBack( Uint16Pair( 15, 16 ) );
 809   stretchRangesY.PushBack( Uint16Pair( 25, 27 ) );
 810   Integration::ResourcePointer ninePatchResource = CustomizeNinePatch( application, ninePatchImageWidth, ninePatchImageHeight, stretchRangesX, stretchRangesY );
 811
 812   ControlRenderer controlRenderer = factory.GetControlRenderer( TEST_NPATCH_FILE_NAME );
 813   DALI_TEST_CHECK( controlRenderer );
 814
 815   Actor actor = Actor::New();
 816
 817   TestGlAbstraction& gl = application.GetGlAbstraction();
 818   TraceCallStack& textureTrace = gl.GetTextureTrace();
 819   textureTrace.Enable(true);
 820
 821   TestControlRendererRender( application, actor, controlRenderer, 1u,
 822                              ImageDimensions(ninePatchImageWidth, ninePatchImageHeight),
 823                              ninePatchResource );
 824
 825   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 826
 827   END_TEST;
 828 }
 829
 830 int UtcDaliRendererFactoryGetNPatchRendererN1(void)
 831 {
 832   //This should still load but display an error image
 833
 834   ToolkitTestApplication application;
 835   tet_infoline( "UtcDaliRendererFactoryGetNPatchRendererN: Request n-patch renderer with an invalid image url" );
 836
 837   RendererFactory factory = RendererFactory::Get();
 838   DALI_TEST_CHECK( factory );
 839
 840   ControlRenderer controlRenderer = factory.GetControlRenderer( "ERROR.9.jpg" );
 841   DALI_TEST_CHECK( controlRenderer );
 842
 843   Actor actor = Actor::New();
 844
 845   //The testkit still has to load a bitmap for the broken renderer image
 846   Integration::Bitmap* bitmap = Integration::Bitmap::New(Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD);
 847   bitmap->GetPackedPixelsProfile()->ReserveBuffer( Pixel::RGBA8888, 100, 100, 100, 100 );
 848
 849   TestGlAbstraction& gl = application.GetGlAbstraction();
 850   TraceCallStack& textureTrace = gl.GetTextureTrace();
 851   textureTrace.Enable(true);
 852
 853   TestControlRendererRender( application, actor, controlRenderer, 1u,
 854                              ImageDimensions(),
 855                              Integration::ResourcePointer(bitmap) );
 856
 857   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 858
 859   END_TEST;
 860 }
 861
 862 int UtcDaliRendererFactoryGetNPatchRendererN2(void)
 863 {
 864   //This should still load but display an error image
 865
 866   ToolkitTestApplication application;
 867   tet_infoline( "UtcDaliRendererFactoryGetNPatchRendererN: Request n-patch renderer with an invalid Property::Map" );
 868
 869   RendererFactory factory = RendererFactory::Get();
 870   DALI_TEST_CHECK( factory );
 871
 872   Property::Map propertyMap;
 873   propertyMap.Insert( "rendererType",  111 );
 874   propertyMap.Insert( "url",  "ERROR.9.jpg" );
 875
 876   ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
 877   DALI_TEST_CHECK( controlRenderer );
 878
 879   Actor actor = Actor::New();
 880
 881   //The testkit still has to load a bitmap for the broken renderer image
 882   Integration::Bitmap* bitmap = Integration::Bitmap::New(Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD);
 883   bitmap->GetPackedPixelsProfile()->ReserveBuffer( Pixel::RGBA8888, 100, 100, 100, 100 );
 884
 885   TestGlAbstraction& gl = application.GetGlAbstraction();
 886   TraceCallStack& textureTrace = gl.GetTextureTrace();
 887   textureTrace.Enable(true);
 888
 889   TestControlRendererRender( application, actor, controlRenderer, 1u,
 890                              ImageDimensions(),
 891                              Integration::ResourcePointer(bitmap) );
 892
 893   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 894
 895   END_TEST;
 896 }
 897
 898 int UtcDaliRendererFactoryGetSvgRenderer(void)
 899 {
 900   ToolkitTestApplication application;
 901   tet_infoline( "UtcDaliRendererFactoryGetSvgRenderer: Request svg renderer with a svg url" );
 902
 903   RendererFactory factory = RendererFactory::Get();
 904   ControlRenderer controlRenderer = factory.GetControlRenderer( TEST_SVG_FILE_NAME );
 905   DALI_TEST_CHECK( controlRenderer );
 906
 907   TestGlAbstraction& gl = application.GetGlAbstraction();
 908   TraceCallStack& textureTrace = gl.GetTextureTrace();
 909   textureTrace.Enable(true);
 910
 911   Actor actor = Actor::New();
 912   actor.SetSize( 200.f, 200.f );
 913   Stage::GetCurrent().Add( actor );
 914   controlRenderer.SetSize( Vector2(200.f, 200.f) );
 915   controlRenderer.SetOnStage( actor );
 916   application.SendNotification();
 917   application.Render();
 918
 919   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 920
 921   EventThreadCallback* eventTrigger = EventThreadCallback::Get();
 922   CallbackBase* callback = eventTrigger->GetCallback();
 923
 924   eventTrigger->WaitingForTrigger( 1 );// waiting until the svg image is rasterized.
 925   CallbackBase::Execute( *callback );
 926
 927   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 928
 929   // waiting for the resource uploading
 930   application.SendNotification();
 931   application.Render();
 932
 933   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 934
 935   END_TEST;
 936 }
 937
 938 //Test if mesh loads correctly when supplied with only the bare minimum requirements, an object file.
 939 int UtcDaliRendererFactoryGetMeshRenderer1(void)
 940 {
 941   ToolkitTestApplication application;
 942   tet_infoline( "UtcDaliRendererFactoryGetMeshRenderer1:  Request mesh renderer with a valid object file only" );
 943
 944   RendererFactory factory = RendererFactory::Get();
 945   DALI_TEST_CHECK( factory );
 946
 947   //Set up renderer properties.
 948   Property::Map propertyMap;
 949   propertyMap.Insert( "rendererType",  "mesh" );
 950   propertyMap.Insert( "objectUrl", TEST_OBJ_FILE_NAME );
 951
 952   ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
 953   DALI_TEST_CHECK( controlRenderer );
 954
 955   Actor actor = Actor::New();
 956   actor.SetSize( 200.f, 200.f );
 957   Stage::GetCurrent().Add( actor );
 958   controlRenderer.SetSize( Vector2( 200.f, 200.f ) );
 959   controlRenderer.SetOnStage( actor );
 960
 961   application.SendNotification();
 962   application.Render( 0 );
 963
 964   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 965
 966   //Tell the platform abstraction that the required resources have been loaded.
 967   TestPlatformAbstraction& platform = application.GetPlatform();
 968   platform.SetAllResourceRequestsAsLoaded();
 969
 970   //Render again to upload the now-loaded textures.
 971   application.SendNotification();
 972   application.Render( 0 );
 973
 974   TestGlAbstraction& gl = application.GetGlAbstraction();
 975
 976   Matrix testScaleMatrix;
 977   testScaleMatrix.SetIdentityAndScale( Vector3( 1.0, -1.0, 1.0 ) );
 978   Matrix actualScaleMatrix;
 979
 980   //Test to see if the object has been successfully loaded.
 981   DALI_TEST_CHECK( gl.GetUniformValue<Matrix>( "uObjectMatrix", actualScaleMatrix ) );
 982   DALI_TEST_EQUALS( actualScaleMatrix, testScaleMatrix, Math::MACHINE_EPSILON_100, TEST_LOCATION );
 983
 984   controlRenderer.SetOffStage( actor );
 985   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 986
 987   END_TEST;
 988 }
 989
 990 //Test if mesh loads correctly when supplied with an object file as well as a blank material file and images directory.
 991 int UtcDaliRendererFactoryGetMeshRenderer2(void)
 992 {
 993   ToolkitTestApplication application;
 994   tet_infoline( "UtcDaliRendererFactoryGetMeshRenderer2:  Request mesh renderer with blank material file and images directory" );
 995
 996   RendererFactory factory = RendererFactory::Get();
 997   DALI_TEST_CHECK( factory );
 998
 999   //Set up renderer properties.
1000   Property::Map propertyMap;
1001   propertyMap.Insert( "rendererType",  "mesh" );
1002   propertyMap.Insert( "objectUrl", TEST_OBJ_FILE_NAME );
1003   propertyMap.Insert( "materialUrl", "" );
1004   propertyMap.Insert( "texturesPath", "" );
1005
1006   ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
1007   DALI_TEST_CHECK( controlRenderer );
1008
1009   //Add renderer to an actor on stage.
1010   Actor actor = Actor::New();
1011   actor.SetSize( 200.f, 200.f );
1012   Stage::GetCurrent().Add( actor );
1013   controlRenderer.SetSize( Vector2( 200.f, 200.f ) );
1014   controlRenderer.SetOnStage( actor );
1015
1016   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
1017
1018   //Attempt to render to queue resource load requests.
1019   application.SendNotification();
1020   application.Render( 0 );
1021
1022   //Tell the platform abstraction that the required resources have been loaded.
1023   TestPlatformAbstraction& platform = application.GetPlatform();
1024   platform.SetAllResourceRequestsAsLoaded();
1025
1026   //Render again to upload the now-loaded textures.
1027   application.SendNotification();
1028   application.Render( 0 );
1029
1030   TestGlAbstraction& gl = application.GetGlAbstraction();
1031
1032   Matrix testScaleMatrix;
1033   testScaleMatrix.SetIdentityAndScale( Vector3( 1.0, -1.0, 1.0 ) );
1034   Matrix actualScaleMatrix;
1035
1036   //Test to see if the object has been successfully loaded.
1037   DALI_TEST_CHECK( gl.GetUniformValue<Matrix>( "uObjectMatrix", actualScaleMatrix ) );
1038   DALI_TEST_EQUALS( actualScaleMatrix, testScaleMatrix, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1039
1040   controlRenderer.SetOffStage( actor );
1041   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
1042
1043   END_TEST;
1044 }
1045
1046 //Test if mesh loads correctly when supplied with all parameters, an object file, a material file and a directory location.
1047 int UtcDaliRendererFactoryGetMeshRenderer3(void)
1048 {
1049   ToolkitTestApplication application;
1050   tet_infoline( "UtcDaliRendererFactoryGetMeshRenderer3:  Request mesh renderer with all parameters correct" );
1051
1052   RendererFactory factory = RendererFactory::Get();
1053   DALI_TEST_CHECK( factory );
1054
1055   //Set up renderer properties.
1056   Property::Map propertyMap;
1057   propertyMap.Insert( "rendererType",  "mesh" );
1058   propertyMap.Insert( "objectUrl", TEST_OBJ_FILE_NAME );
1059   propertyMap.Insert( "materialUrl", TEST_MTL_FILE_NAME );
1060   propertyMap.Insert( "texturesPath", TEST_RESOURCE_DIR "/" );
1061
1062   ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
1063   DALI_TEST_CHECK( controlRenderer );
1064
1065   //Add renderer to an actor on stage.
1066   Actor actor = Actor::New();
1067   actor.SetSize( 200.f, 200.f );
1068   Stage::GetCurrent().Add( actor );
1069   controlRenderer.SetSize( Vector2( 200.f, 200.f ) );
1070   controlRenderer.SetOnStage( actor );
1071
1072   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
1073
1074   //Attempt to render to queue resource load requests.
1075   application.SendNotification();
1076   application.Render( 0 );
1077
1078   //Tell the platform abstraction that the required resources have been loaded.
1079   TestPlatformAbstraction& platform = application.GetPlatform();
1080   platform.SetAllResourceRequestsAsLoaded();
1081
1082   //Render again to upload the now-loaded textures.
1083   application.SendNotification();
1084   application.Render( 0 );
1085
1086   TestGlAbstraction& gl = application.GetGlAbstraction();
1087
1088   Matrix testScaleMatrix;
1089   testScaleMatrix.SetIdentityAndScale( Vector3( 1.0, -1.0, 1.0 ) );
1090   Matrix actualScaleMatrix;
1091
1092   //Test to see if the object has been successfully loaded.
1093   DALI_TEST_CHECK( gl.GetUniformValue<Matrix>( "uObjectMatrix", actualScaleMatrix ) );
1094   DALI_TEST_EQUALS( actualScaleMatrix, testScaleMatrix, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1095
1096   controlRenderer.SetOffStage( actor );
1097   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
1098
1099   END_TEST;
1100 }
1101
1102 //Test if mesh renderer can load a correctly supplied mesh without a normal map or gloss map in the material file.
1103 int UtcDaliRendererFactoryGetMeshRenderer4(void)
1104 {
1105   ToolkitTestApplication application;
1106   tet_infoline( "UtcDaliRendererFactoryGetMeshRenderer4:  Request mesh renderer with diffuse texture but not normal or gloss." );
1107
1108   RendererFactory factory = RendererFactory::Get();
1109   DALI_TEST_CHECK( factory );
1110
1111   //Set up renderer properties.
1112   Property::Map propertyMap;
1113   propertyMap.Insert( "rendererType",  "mesh" );
1114   propertyMap.Insert( "objectUrl", TEST_OBJ_FILE_NAME );
1115   propertyMap.Insert( "materialUrl", TEST_SIMPLE_MTL_FILE_NAME );
1116   propertyMap.Insert( "texturesPath", TEST_RESOURCE_DIR "/" );
1117
1118   ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
1119   DALI_TEST_CHECK( controlRenderer );
1120
1121   //Add renderer to an actor on stage.
1122   Actor actor = Actor::New();
1123   actor.SetSize( 200.f, 200.f );
1124   Stage::GetCurrent().Add( actor );
1125   controlRenderer.SetSize( Vector2( 200.f, 200.f ) );
1126   controlRenderer.SetOnStage( actor );
1127
1128   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
1129
1130   //Attempt to render to queue resource load requests.
1131   application.SendNotification();
1132   application.Render( 0 );
1133
1134   //Tell the platform abstraction that the required resources have been loaded.
1135   TestPlatformAbstraction& platform = application.GetPlatform();
1136   platform.SetAllResourceRequestsAsLoaded();
1137
1138   //Render again to upload the now-loaded textures.
1139   application.SendNotification();
1140   application.Render( 0 );
1141
1142   TestGlAbstraction& gl = application.GetGlAbstraction();
1143
1144   Matrix testScaleMatrix;
1145   testScaleMatrix.SetIdentityAndScale( Vector3( 1.0, -1.0, 1.0 ) );
1146   Matrix actualScaleMatrix;
1147
1148   //Test to see if the object has been successfully loaded.
1149   DALI_TEST_CHECK( gl.GetUniformValue<Matrix>( "uObjectMatrix", actualScaleMatrix ) );
1150   DALI_TEST_EQUALS( actualScaleMatrix, testScaleMatrix, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1151
1152   controlRenderer.SetOffStage( actor );
1153   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
1154
1155   END_TEST;
1156 }
1157
1158 //Test if mesh renderer handles the case of lacking an object file.
1159 int UtcDaliRendererFactoryGetMeshRendererN1(void)
1160 {
1161   ToolkitTestApplication application;
1162   tet_infoline( "UtcDaliRendererFactoryGetMeshRendererN1:  Request mesh renderer without object file" );
1163
1164   RendererFactory factory = RendererFactory::Get();
1165   DALI_TEST_CHECK( factory );
1166
1167   //Set up renderer properties.
1168   Property::Map propertyMap;
1169   propertyMap.Insert( "rendererType",  "mesh" );
1170   propertyMap.Insert( "materialUrl", TEST_MTL_FILE_NAME );
1171   propertyMap.Insert( "texturesPath", TEST_RESOURCE_DIR "/" );
1172
1173   ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
1174   DALI_TEST_CHECK( controlRenderer );
1175
1176   //Add renderer to an actor on stage.
1177   Actor actor = Actor::New();
1178   actor.SetSize( 200.f, 200.f );
1179   Stage::GetCurrent().Add( actor );
1180   controlRenderer.SetSize( Vector2( 200.f, 200.f ) );
1181   controlRenderer.SetOnStage( actor );
1182
1183   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
1184
1185   //Attempt to render to queue resource load requests.
1186   application.SendNotification();
1187   application.Render( 0 );
1188
1189   //Tell the platform abstraction that the required resources have been loaded.
1190   TestPlatformAbstraction& platform = application.GetPlatform();
1191   platform.SetAllResourceRequestsAsLoaded();
1192
1193   //Render again to upload the now-loaded textures.
1194   application.SendNotification();
1195   application.Render( 0 );
1196
1197   TestGlAbstraction& gl = application.GetGlAbstraction();
1198
1199   //Test to see if the object has not been loaded, as expected.
1200   Matrix scaleMatrix;
1201   DALI_TEST_CHECK( ! gl.GetUniformValue<Matrix>( "uObjectMatrix", scaleMatrix ) );
1202
1203   controlRenderer.SetOffStage( actor );
1204   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
1205
1206   END_TEST;
1207 }
1208
1209 //Test if mesh renderer handles the case of being passed invalid material and images urls.
1210 int UtcDaliRendererFactoryGetMeshRendererN2(void)
1211 {
1212   ToolkitTestApplication application;
1213   tet_infoline( "UtcDaliRendererFactoryGetMeshRendererN2:  Request mesh renderer with invalid material and images urls" );
1214
1215   RendererFactory factory = RendererFactory::Get();
1216   DALI_TEST_CHECK( factory );
1217
1218   //Set up renderer properties.
1219   Property::Map propertyMap;
1220   propertyMap.Insert( "rendererType",  "mesh" );
1221   propertyMap.Insert( "objectUrl", TEST_OBJ_FILE_NAME );
1222   propertyMap.Insert( "materialUrl", "invalid" );
1223   propertyMap.Insert( "texturesPath", "also invalid" );
1224
1225   ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
1226   DALI_TEST_CHECK( controlRenderer );
1227
1228   //Add renderer to an actor on stage.
1229   Actor actor = Actor::New();
1230   actor.SetSize( 200.f, 200.f );
1231   Stage::GetCurrent().Add( actor );
1232   controlRenderer.SetSize( Vector2( 200.f, 200.f ) );
1233   controlRenderer.SetOnStage( actor );
1234
1235   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
1236
1237   //Attempt to render to queue resource load requests.
1238   application.SendNotification();
1239   application.Render( 0 );
1240
1241   //Tell the platform abstraction that the required resources have been loaded.
1242   TestPlatformAbstraction& platform = application.GetPlatform();
1243   platform.SetAllResourceRequestsAsLoaded();
1244
1245   //Render again to upload the now-loaded textures.
1246   application.SendNotification();
1247   application.Render( 0 );
1248
1249   TestGlAbstraction& gl = application.GetGlAbstraction();
1250
1251   //Test to see if the object has not been loaded, as expected.
1252   Matrix scaleMatrix;
1253   DALI_TEST_CHECK( ! gl.GetUniformValue<Matrix>( "uObjectMatrix", scaleMatrix ) );
1254
1255   controlRenderer.SetOffStage( actor );
1256   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
1257
1258   END_TEST;
1259 }
1260
1261 //Test if mesh renderer handles the case of being passed an invalid object url
1262 int UtcDaliRendererFactoryGetMeshRendererN3(void)
1263 {
1264   ToolkitTestApplication application;
1265   tet_infoline( "UtcDaliRendererFactoryGetMeshRendererN3:  Request mesh renderer with invalid object url" );
1266
1267   RendererFactory factory = RendererFactory::Get();
1268   DALI_TEST_CHECK( factory );
1269
1270   //Set up renderer properties.
1271   Property::Map propertyMap;
1272   propertyMap.Insert( "rendererType",  "mesh" );
1273   propertyMap.Insert( "objectUrl", "invalid" );
1274   propertyMap.Insert( "materialUrl", TEST_MTL_FILE_NAME );
1275   propertyMap.Insert( "texturesPath", TEST_RESOURCE_DIR "/" );
1276
1277   ControlRenderer controlRenderer = factory.GetControlRenderer( propertyMap );
1278   DALI_TEST_CHECK( controlRenderer );
1279
1280   //Add renderer to an actor on stage.
1281   Actor actor = Actor::New();
1282   actor.SetSize( 200.f, 200.f );
1283   Stage::GetCurrent().Add( actor );
1284   controlRenderer.SetSize( Vector2( 200.f, 200.f ) );
1285   controlRenderer.SetOnStage( actor );
1286
1287   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
1288
1289   //Attempt to render to queue resource load requests.
1290   application.SendNotification();
1291   application.Render( 0 );
1292
1293   //Tell the platform abstraction that the required resources have been loaded.
1294   TestPlatformAbstraction& platform = application.GetPlatform();
1295   platform.SetAllResourceRequestsAsLoaded();
1296
1297   //Render again to upload the now-loaded textures.
1298   application.SendNotification();
1299   application.Render( 0 );
1300
1301   TestGlAbstraction& gl = application.GetGlAbstraction();
1302
1303   //Test to see if the object has not been loaded, as expected.
1304   Matrix scaleMatrix;
1305   DALI_TEST_CHECK( ! gl.GetUniformValue<Matrix>( "uObjectMatrix", scaleMatrix ) );
1306
1307   controlRenderer.SetOffStage( actor );
1308   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
1309
1310   END_TEST;
1311 }
1312
1313 int UtcDaliRendererFactoryResetRenderer1(void)
1314 {
1315   ToolkitTestApplication application;
1316   tet_infoline( "UtcDaliRendererFactoryResetRenderer1" );
1317
1318   RendererFactory factory = RendererFactory::Get();
1319   DALI_TEST_CHECK( factory );
1320
1321   ControlRenderer controlRenderer = factory.GetControlRenderer( Color::RED );
1322   DALI_TEST_CHECK( controlRenderer );
1323
1324   Actor actor = Actor::New();
1325   TestControlRendererRender( application, actor, controlRenderer );
1326
1327   Vector4 actualValue(Vector4::ZERO);
1328   TestGlAbstraction& gl = application.GetGlAbstraction();
1329   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "mixColor", actualValue ) );
1330   DALI_TEST_EQUALS( actualValue, Color::RED, TEST_LOCATION );
1331
1332   factory.ResetRenderer( controlRenderer, actor, Color::GREEN );
1333   application.SendNotification();
1334   application.Render(0);
1335   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "mixColor", actualValue ) );
1336   DALI_TEST_EQUALS( actualValue, Color::GREEN, TEST_LOCATION );
1337
1338   Image bufferImage = CreateBufferImage( 100, 200, Vector4( 1.f, 1.f, 1.f, 1.f ) );
1339   factory.ResetRenderer( controlRenderer, actor, bufferImage );
1340
1341   Actor actor2 = Actor::New();
1342   actor2.SetSize(200.f, 200.f);
1343   Stage::GetCurrent().Add( actor2 );
1344   controlRenderer.SetSize(Vector2(200.f, 200.f));
1345   controlRenderer.SetOnStage( actor2 );
1346   application.SendNotification();
1347   application.Render(0);
1348
1349   END_TEST;
1350 }
1351
1352 int UtcDaliRendererFactoryResetRenderer2(void)
1353 {
1354   ToolkitTestApplication application;
1355   tet_infoline( "UtcDaliRendererFactoryResetRenderer2" );
1356
1357   Actor actor = Actor::New();
1358   actor.SetSize(200.f, 200.f);
1359   Stage::GetCurrent().Add( actor );
1360   RendererFactory factory = RendererFactory::Get();
1361   DALI_TEST_CHECK( factory );
1362
1363   Image resourceImage = ResourceImage::New(TEST_IMAGE_FILE_NAME);
1364   ControlRenderer controlRenderer = factory.GetControlRenderer( resourceImage );
1365   DALI_TEST_CHECK( controlRenderer );
1366   controlRenderer.SetSize(Vector2(200.f, 200.f));
1367   controlRenderer.SetOnStage( actor );
1368   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
1369
1370   application.SendNotification();
1371   application.Render(0);
1372
1373   Image bufferImage = CreateBufferImage( 100, 200, Vector4( 1.f, 1.f, 1.f, 1.f ) );
1374   factory.ResetRenderer( controlRenderer, actor, bufferImage );
1375   application.SendNotification();
1376   application.Render(0);
1377
1378   factory.ResetRenderer( controlRenderer, actor, Color::RED );
1379
1380   Actor actor2 = Actor::New();
1381   actor2.SetSize(200.f, 200.f);
1382   Stage::GetCurrent().Add( actor2 );
1383   controlRenderer.SetSize(Vector2(200.f, 200.f));
1384   controlRenderer.SetOnStage( actor2 );
1385   TestGlAbstraction& gl = application.GetGlAbstraction();
1386   application.SendNotification();
1387   application.Render(0);
1388   Vector4 actualValue(Vector4::ZERO);
1389   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "mixColor", actualValue ) );
1390   DALI_TEST_EQUALS( actualValue, Color::RED, TEST_LOCATION );
1391
1392   END_TEST;
1393 }
1394
1395 int UtcDaliRendererFactoryResetRenderer3(void)
1396 {
1397   ToolkitTestApplication application;
1398   tet_infoline( "UtcDaliRendererFactoryResetRenderer3" );
1399
1400   Actor actor = Actor::New();
1401   actor.SetSize(200.f, 200.f);
1402   Stage::GetCurrent().Add( actor );
1403   RendererFactory factory = RendererFactory::Get();
1404   DALI_TEST_CHECK( factory );
1405
1406   // Get renderer for rendering a resource image
1407   Image resourceImage = ResourceImage::New(TEST_IMAGE_FILE_NAME);
1408   ControlRenderer controlRenderer = factory.GetControlRenderer( resourceImage );
1409   DALI_TEST_CHECK( controlRenderer );
1410   controlRenderer.SetSize(Vector2(200.f, 200.f));
1411   controlRenderer.SetOnStage( actor );
1412   application.SendNotification();
1413   application.Render();
1414
1415   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
1416
1417   // reset the renderer to renderer a svg image
1418   factory.ResetRenderer( controlRenderer, actor, TEST_SVG_FILE_NAME, ImageDimensions( 100, 100 ) );
1419   application.SendNotification();
1420   application.Render();
1421
1422   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
1423
1424   EventThreadCallback* eventTrigger = EventThreadCallback::Get();
1425   CallbackBase* callback = eventTrigger->GetCallback();
1426
1427   eventTrigger->WaitingForTrigger( 1 );// waiting until the svg image is rasterized.
1428   CallbackBase::Execute( *callback );
1429
1430   END_TEST;
1431 }
1432
1433 //Test resetting mesh and primitive shape renderers
1434 int UtcDaliRendererFactoryResetRenderer4(void)
1435 {
1436   ToolkitTestApplication application;
1437   tet_infoline( "UtcDaliRendererFactoryResetRenderer4:  Mesh and primitive renderers" );
1438
1439   Actor actor = Actor::New();
1440   actor.SetSize( 200.f, 200.f );
1441   Stage::GetCurrent().Add( actor );
1442   RendererFactory factory = RendererFactory::Get();
1443   DALI_TEST_CHECK( factory );
1444
1445   Property::Map map;
1446
1447   //******
1448
1449   //Start with basic color renderer
1450   ControlRenderer controlRenderer = factory.GetControlRenderer( Color::RED );
1451   DALI_TEST_CHECK( controlRenderer );
1452
1453   TestControlRendererRender( application, actor, controlRenderer );
1454
1455   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
1456
1457   //Ensure set correctly.
1458   Vector4 actualValue( Vector4::ZERO );
1459   TestGlAbstraction& gl = application.GetGlAbstraction();
1460   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "mixColor", actualValue ) );
1461   DALI_TEST_EQUALS( actualValue, Color::RED, TEST_LOCATION );
1462
1463   //******
1464
1465   //Reset to mesh renderer
1466   map.Insert( "rendererType", "mesh" );
1467   map.Insert( "objectUrl", TEST_OBJ_FILE_NAME );
1468   map.Insert( "materialUrl", TEST_MTL_FILE_NAME );
1469   map.Insert( "texturesPath", TEST_RESOURCE_DIR "/" );
1470   factory.ResetRenderer( controlRenderer, actor, map );
1471   application.SendNotification();
1472   application.Render( 0 );
1473
1474   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
1475
1476   //Tell the platform abstraction that the required resources have been loaded.
1477   TestPlatformAbstraction& platform = application.GetPlatform();
1478   platform.SetAllResourceRequestsAsLoaded();
1479
1480   //Render again to upload the now-loaded textures.
1481   application.SendNotification();
1482   application.Render( 0 );
1483
1484   //Ensure set correctly.
1485   controlRenderer.CreatePropertyMap( map );
1486   DALI_TEST_EQUALS( map.Find( "objectUrl", Property::STRING )->Get<std::string>(), TEST_OBJ_FILE_NAME, TEST_LOCATION );
1487
1488   Matrix testScaleMatrix;
1489   testScaleMatrix.SetIdentityAndScale( Vector3( 1.0, -1.0, 1.0 ) );
1490   Matrix actualScaleMatrix;
1491
1492   //Test to see if the object has been successfully loaded.
1493   DALI_TEST_CHECK( gl.GetUniformValue<Matrix>( "uObjectMatrix", actualScaleMatrix ) );
1494   DALI_TEST_EQUALS( actualScaleMatrix, testScaleMatrix, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1495
1496   //******
1497
1498   //Reset back to color renderer
1499   factory.ResetRenderer( controlRenderer, actor, Color::GREEN );
1500   application.SendNotification();
1501   application.Render( 0 );
1502
1503   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
1504
1505   //Ensure set correctly.
1506   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "mixColor", actualValue ) );
1507   DALI_TEST_EQUALS( actualValue, Color::GREEN, TEST_LOCATION );
1508
1509   //******
1510
1511   END_TEST;
1512 }