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