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.CreateControlRenderer(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   Dali::Property::Map map;
 323   map[ "rendererType" ] = "color";
 324   map[ "mixColor" ] = testColor;
 325   ControlRenderer controlRenderer = factory.CreateControlRenderer( map );
 326   DALI_TEST_CHECK( controlRenderer );
 327
 328   Actor actor = Actor::New();
 329   TestControlRendererRender( application, actor, controlRenderer );
 330
 331   Vector4 actualValue(Vector4::ZERO);
 332   TestGlAbstraction& gl = application.GetGlAbstraction();
 333   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "mixColor", actualValue ) );
 334   DALI_TEST_EQUALS( actualValue, testColor, TEST_LOCATION );
 335
 336   controlRenderer.SetOffStage( actor );
 337   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 338
 339   END_TEST;
 340 }
 341
 342 int UtcDaliRendererFactoryGetBorderRenderer1(void)
 343 {
 344   ToolkitTestApplication application;
 345   tet_infoline( "UtcDaliRendererFactoryGetBorderRenderer1:  Request border renderer with a Property::Map" );
 346
 347   RendererFactory factory = RendererFactory::Get();
 348   DALI_TEST_CHECK( factory );
 349
 350   Property::Map propertyMap;
 351   Vector4 testColor( 1.f, 0.5f, 0.3f, 0.2f );
 352   float testSize = 5.f;
 353   propertyMap.Insert("rendererType",  "border");
 354   propertyMap.Insert("borderColor",  testColor);
 355   propertyMap.Insert("borderSize",  testSize);
 356
 357   ControlRenderer controlRenderer = factory.CreateControlRenderer(propertyMap);
 358   DALI_TEST_CHECK( controlRenderer );
 359
 360   Actor actor = Actor::New();
 361   actor.SetSize(200.f, 200.f);
 362   Stage::GetCurrent().Add( actor );
 363   controlRenderer.SetSize(Vector2(200.f, 200.f));
 364   controlRenderer.SetOnStage( actor );
 365
 366   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 367   int blendMode = actor.GetRendererAt(0u).GetProperty<int>( Renderer::Property::BLEND_MODE );
 368   DALI_TEST_EQUALS( static_cast<BlendingMode::Type>(blendMode), BlendingMode::ON, TEST_LOCATION );
 369
 370   TestGlAbstraction& gl = application.GetGlAbstraction();
 371
 372   application.SendNotification();
 373   application.Render(0);
 374
 375   Vector4 actualColor(Vector4::ZERO);
 376   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "borderColor", actualColor ) );
 377   DALI_TEST_EQUALS( actualColor, testColor, TEST_LOCATION );
 378
 379   float actualSize = 0.f;
 380   DALI_TEST_CHECK( gl.GetUniformValue<float>( "borderSize", actualSize ) );
 381   DALI_TEST_EQUALS( actualSize, testSize, TEST_LOCATION );
 382
 383   controlRenderer.SetOffStage( actor );
 384   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 385
 386   END_TEST;
 387 }
 388
 389 int UtcDaliRendererFactoryGetBorderRenderer2(void)
 390 {
 391   ToolkitTestApplication application;
 392   tet_infoline( "UtcDaliRendererFactoryGetBorderRenderer2:  Request border renderer with a borderSize and a borderColor" );
 393
 394   RendererFactory factory = RendererFactory::Get();
 395   DALI_TEST_CHECK( factory );
 396
 397   Vector4 testColor( 1.f, 0.5f, 0.3f, 1.f );
 398   float testSize = 5.f;
 399
 400   Dali::Property::Map propertyMap;
 401   propertyMap[ "rendererType" ] = "border";
 402   propertyMap[ "borderColor"  ] = testColor;
 403   propertyMap[ "borderSize"   ] = testSize;
 404   ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
 405   DALI_TEST_CHECK( controlRenderer );
 406
 407   Actor actor = Actor::New();
 408   actor.SetSize(200.f, 200.f);
 409   Stage::GetCurrent().Add( actor );
 410   controlRenderer.SetSize(Vector2(200.f, 200.f));
 411   controlRenderer.SetOnStage( actor );
 412
 413   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 414
 415   TestGlAbstraction& gl = application.GetGlAbstraction();
 416
 417   application.SendNotification();
 418   application.Render(0);
 419
 420   int blendMode = actor.GetRendererAt(0u).GetProperty<int>( Renderer::Property::BLEND_MODE );
 421   DALI_TEST_EQUALS( static_cast<BlendingMode::Type>(blendMode), BlendingMode::AUTO, TEST_LOCATION );
 422
 423   Vector4 actualColor(Vector4::ZERO);
 424   DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "borderColor", actualColor ) );
 425   DALI_TEST_EQUALS( actualColor, testColor, TEST_LOCATION );
 426
 427   float actualSize = 0.f;
 428   DALI_TEST_CHECK( gl.GetUniformValue<float>( "borderSize", actualSize ) );
 429   DALI_TEST_EQUALS( actualSize, testSize, TEST_LOCATION );
 430
 431   controlRenderer.SetOffStage( actor );
 432
 433   // enable the anti-aliasing
 434   Dali::Property::Map map;
 435   map[ "rendererType" ] = "border";
 436   map[ "borderColor"  ] = testColor;
 437   map[ "borderSize"   ] = testSize;
 438   map[ "antiAliasing"   ] = true;
 439   controlRenderer = factory.CreateControlRenderer( map );
 440   controlRenderer.SetOnStage( actor );
 441
 442   application.SendNotification();
 443   application.Render(0);
 444   blendMode = actor.GetRendererAt(0u).GetProperty<int>( Renderer::Property::BLEND_MODE );
 445   DALI_TEST_EQUALS( static_cast<BlendingMode::Type>(blendMode), BlendingMode::ON, TEST_LOCATION );
 446
 447   END_TEST;
 448 }
 449
 450 int UtcDaliRendererFactoryGetLinearGradientRenderer(void)
 451 {
 452   ToolkitTestApplication application;
 453   tet_infoline("UtcDaliRendererFactoryGetRadialGradientRenderer");
 454
 455   RendererFactory factory = RendererFactory::Get();
 456   DALI_TEST_CHECK( factory );
 457
 458   Property::Map propertyMap;
 459   propertyMap.Insert("rendererType",  "gradient");
 460
 461   Vector2 start(-1.f, -1.f);
 462   Vector2 end(1.f, 1.f);
 463   propertyMap.Insert("startPosition",   start);
 464   propertyMap.Insert("endPosition",   end);
 465   propertyMap.Insert("spreadMethod",   "repeat");
 466
 467   Property::Array stopOffsets;
 468   stopOffsets.PushBack( 0.2f );
 469   stopOffsets.PushBack( 0.8f );
 470   propertyMap.Insert("stopOffset",   stopOffsets);
 471
 472   Property::Array stopColors;
 473   stopColors.PushBack( Color::RED );
 474   stopColors.PushBack( Color::GREEN );
 475   propertyMap.Insert("stopColor",   stopColors);
 476
 477   ControlRenderer controlRenderer = factory.CreateControlRenderer(propertyMap);
 478   DALI_TEST_CHECK( controlRenderer );
 479
 480   // A lookup texture is generated and pass to shader as sampler
 481   Actor actor = Actor::New();
 482   TestControlRendererRender( application, actor, controlRenderer, 1u );
 483
 484   controlRenderer.SetOffStage( actor );
 485   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 486
 487   END_TEST;
 488 }
 489
 490 int UtcDaliRendererFactoryGetRadialGradientRenderer(void)
 491 {
 492   ToolkitTestApplication application;
 493   tet_infoline("UtcDaliRendererFactoryGetRadialGradientRenderer");
 494
 495   RendererFactory factory = RendererFactory::Get();
 496   DALI_TEST_CHECK( factory );
 497
 498   Property::Map propertyMap;
 499   propertyMap.Insert("rendererType",  "gradient");
 500
 501   Vector2 center(100.f, 100.f);
 502   float radius = 100.f;
 503   propertyMap.Insert("units",  "userSpace");
 504   propertyMap.Insert("center",  center);
 505   propertyMap.Insert("radius",  radius);
 506
 507   Property::Array stopOffsets;
 508   stopOffsets.PushBack( 0.0f );
 509   stopOffsets.PushBack( 1.f );
 510   propertyMap.Insert("stopOffset",   stopOffsets);
 511
 512   Property::Array stopColors;
 513   stopColors.PushBack( Color::RED );
 514   stopColors.PushBack( Color::GREEN );
 515   propertyMap.Insert("stopColor",   stopColors);
 516
 517   ControlRenderer controlRenderer = factory.CreateControlRenderer(propertyMap);
 518   DALI_TEST_CHECK( controlRenderer );
 519
 520   // A lookup texture is generated and pass to shader as sampler
 521   Actor actor = Actor::New();
 522   TestControlRendererRender( application, actor, controlRenderer, 1u );
 523
 524   Matrix3 alignMatrix( radius, 0.f, 0.f, 0.f, radius, 0.f, center.x, center.y, 1.f );
 525   alignMatrix.Invert();
 526
 527   Matrix3 actualValue( Matrix3::IDENTITY );
 528   TestGlAbstraction& gl = application.GetGlAbstraction();
 529   DALI_TEST_CHECK( gl.GetUniformValue<Matrix3>( "uAlignmentMatrix", actualValue ) );
 530   DALI_TEST_EQUALS( actualValue, alignMatrix, Math::MACHINE_EPSILON_100, TEST_LOCATION );
 531
 532   END_TEST;
 533 }
 534
 535 int UtcDaliRendererFactoryDefaultOffsetsGradientRenderer(void)
 536 {
 537   ToolkitTestApplication application;
 538   tet_infoline("UtcDaliRendererFactoryGetRadialGradientRenderer");
 539
 540   RendererFactory factory = RendererFactory::Get();
 541   DALI_TEST_CHECK( factory );
 542
 543   Property::Map propertyMap;
 544   propertyMap.Insert("rendererType",  "gradient");
 545
 546   Vector2 start(-1.f, -1.f);
 547   Vector2 end(1.f, 1.f);
 548   propertyMap.Insert("startPosition",   start);
 549   propertyMap.Insert("endPosition",   end);
 550   propertyMap.Insert("spreadMethod",   "repeat");
 551
 552   Property::Array stopColors;
 553   stopColors.PushBack( Color::RED );
 554   stopColors.PushBack( Color::GREEN );
 555   propertyMap.Insert("stopColor",   stopColors);
 556
 557   ControlRenderer controlRenderer = factory.CreateControlRenderer(propertyMap);
 558   DALI_TEST_CHECK( controlRenderer );
 559
 560   // A lookup texture is generated and pass to shader as sampler
 561   Actor actor = Actor::New();
 562   TestControlRendererRender( application, actor, controlRenderer, 1u );
 563
 564   controlRenderer.SetOffStage( actor );
 565   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 566
 567   END_TEST;
 568 }
 569
 570 int UtcDaliRendererFactoryGetImageRenderer1(void)
 571 {
 572   ToolkitTestApplication application;
 573   tet_infoline( "UtcDaliRendererFactoryGetImageRenderer1: Request image renderer with a Property::Map" );
 574
 575   RendererFactory factory = RendererFactory::Get();
 576   DALI_TEST_CHECK( factory );
 577
 578   Property::Map propertyMap;
 579   propertyMap.Insert( "rendererType",  "image" );
 580   propertyMap.Insert( "url",  TEST_IMAGE_FILE_NAME );
 581
 582   ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
 583   DALI_TEST_CHECK( controlRenderer );
 584
 585   Actor actor = Actor::New();
 586   // For tesing the LoadResourceFunc is called, a big image size should be set, so the atlasing is not applied.
 587   // Image with a size smaller than 512*512 will be uploaded as a part of the atlas.
 588
 589   const int width=512;
 590   const int height=513;
 591   TestGlAbstraction& gl = application.GetGlAbstraction();
 592   TraceCallStack& textureTrace = gl.GetTextureTrace();
 593   textureTrace.Enable(true);
 594
 595   Integration::Bitmap* bitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD );
 596   bitmap->GetPackedPixelsProfile()->ReserveBuffer( Pixel::RGBA8888, width, height,width, height );
 597
 598   TestControlRendererRender( application, actor, controlRenderer, 1u,
 599                              ImageDimensions(width, height),
 600                              Integration::ResourcePointer( bitmap ) );
 601
 602   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 603
 604   controlRenderer.SetOffStage( actor );
 605   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 606
 607   END_TEST;
 608 }
 609
 610 int UtcDaliRendererFactoryGetImageRenderer2(void)
 611 {
 612   ToolkitTestApplication application;
 613   tet_infoline( "UtcDaliRendererFactoryGetImageRenderer2: Request image renderer with an image handle" );
 614
 615   RendererFactory factory = RendererFactory::Get();
 616   DALI_TEST_CHECK( factory );
 617
 618   Image image = ResourceImage::New(TEST_IMAGE_FILE_NAME);
 619   ControlRenderer controlRenderer = factory.CreateControlRenderer( image );
 620
 621   Actor actor = Actor::New();
 622   // For tesing the LoadResourceFunc is called, a big image size should be set, so the atlasing is not applied.
 623   // Image with a size smaller than 512*512 will be uploaded as a part of the atlas.
 624
 625   const int width=512;
 626   const int height=513;
 627
 628   Integration::Bitmap* bitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD );
 629   bitmap->GetPackedPixelsProfile()->ReserveBuffer( Pixel::RGBA8888, width, height,width, height );
 630
 631   TestGlAbstraction& gl = application.GetGlAbstraction();
 632   TraceCallStack& textureTrace = gl.GetTextureTrace();
 633   textureTrace.Enable(true);
 634
 635   TestControlRendererRender( application, actor, controlRenderer, 1u,
 636                              ImageDimensions(width, height),
 637                              Integration::ResourcePointer(bitmap) );
 638
 639   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 640
 641   END_TEST;
 642 }
 643
 644 int UtcDaliRendererFactoryGetNPatchRenderer1(void)
 645 {
 646   ToolkitTestApplication application;
 647   tet_infoline( "UtcDaliRendererFactoryGetNPatchRenderer1: Request 9-patch renderer with a Property::Map" );
 648
 649   RendererFactory factory = RendererFactory::Get();
 650   DALI_TEST_CHECK( factory );
 651
 652   const unsigned int ninePatchImageHeight = 18;
 653   const unsigned int ninePatchImageWidth = 28;
 654   StretchRanges stretchRangesX;
 655   stretchRangesX.PushBack( Uint16Pair( 2, 3 ) );
 656   StretchRanges stretchRangesY;
 657   stretchRangesY.PushBack( Uint16Pair( 4, 5 ) );
 658   Integration::ResourcePointer ninePatchResource = CustomizeNinePatch( application, ninePatchImageWidth, ninePatchImageHeight, stretchRangesX, stretchRangesY );
 659
 660   Property::Map propertyMap;
 661   propertyMap.Insert( "rendererType",  "image" );
 662   propertyMap.Insert( "url",  TEST_NPATCH_FILE_NAME );
 663   {
 664     tet_infoline( "whole grid" );
 665     ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
 666     DALI_TEST_CHECK( controlRenderer );
 667
 668     Actor actor = Actor::New();
 669
 670     TestGlAbstraction& gl = application.GetGlAbstraction();
 671     TraceCallStack& textureTrace = gl.GetTextureTrace();
 672     textureTrace.Enable(true);
 673
 674     TestControlRendererRender( application, actor, controlRenderer, 1u,
 675                                ImageDimensions(ninePatchImageWidth, ninePatchImageHeight),
 676                                ninePatchResource );
 677
 678     DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 679   }
 680
 681   propertyMap.Insert( "borderOnly",  true );
 682   {
 683     tet_infoline( "border only" );
 684     ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
 685     DALI_TEST_CHECK( controlRenderer );
 686
 687     Actor actor = Actor::New();
 688
 689     TestGlAbstraction& gl = application.GetGlAbstraction();
 690     TraceCallStack& textureTrace = gl.GetTextureTrace();
 691     textureTrace.Enable(true);
 692
 693     TestControlRendererRender( application, actor, controlRenderer, 1u,
 694                                ImageDimensions(ninePatchImageWidth, ninePatchImageHeight),
 695                                ninePatchResource );
 696
 697     DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 698   }
 699
 700   END_TEST;
 701 }
 702
 703 int UtcDaliRendererFactoryGetNPatchRenderer2(void)
 704 {
 705   ToolkitTestApplication application;
 706   tet_infoline( "UtcDaliRendererFactoryGetNPatchRenderer2: Request n-patch renderer with a Property::Map" );
 707
 708   RendererFactory factory = RendererFactory::Get();
 709   DALI_TEST_CHECK( factory );
 710
 711   const unsigned int ninePatchImageWidth = 18;
 712   const unsigned int ninePatchImageHeight = 28;
 713   StretchRanges stretchRangesX;
 714   stretchRangesX.PushBack( Uint16Pair( 2, 3 ) );
 715   stretchRangesX.PushBack( Uint16Pair( 5, 7 ) );
 716   stretchRangesX.PushBack( Uint16Pair( 12, 15 ) );
 717   StretchRanges stretchRangesY;
 718   stretchRangesY.PushBack( Uint16Pair( 4, 5 ) );
 719   stretchRangesY.PushBack( Uint16Pair( 8, 12 ) );
 720   stretchRangesY.PushBack( Uint16Pair( 15, 16 ) );
 721   stretchRangesY.PushBack( Uint16Pair( 25, 27 ) );
 722   Integration::ResourcePointer ninePatchResource = CustomizeNinePatch( application, ninePatchImageWidth, ninePatchImageHeight, stretchRangesX, stretchRangesY );
 723
 724   Property::Map propertyMap;
 725   propertyMap.Insert( "rendererType",  "image" );
 726   propertyMap.Insert( "url",  TEST_NPATCH_FILE_NAME );
 727   {
 728     ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
 729     DALI_TEST_CHECK( controlRenderer );
 730
 731     Actor actor = Actor::New();
 732     TestGlAbstraction& gl = application.GetGlAbstraction();
 733     TraceCallStack& textureTrace = gl.GetTextureTrace();
 734     textureTrace.Enable(true);
 735
 736     TestControlRendererRender( application, actor, controlRenderer, 1u,
 737                                ImageDimensions(ninePatchImageWidth, ninePatchImageHeight),
 738                                ninePatchResource );
 739
 740
 741     DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 742
 743     controlRenderer.SetOffStage( actor );
 744     DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 745   }
 746
 747   propertyMap.Insert( "borderOnly",  true );
 748   {
 749     tet_infoline( "border only" );
 750     ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
 751     DALI_TEST_CHECK( controlRenderer );
 752
 753     TestGlAbstraction& gl = application.GetGlAbstraction();
 754     TraceCallStack& textureTrace = gl.GetTextureTrace();
 755     textureTrace.Enable(true);
 756     Actor actor = Actor::New();
 757     TestControlRendererRender( application, actor, controlRenderer, 1u,
 758                                ImageDimensions(ninePatchImageWidth, ninePatchImageHeight),
 759                                ninePatchResource );
 760
 761
 762     DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 763
 764     controlRenderer.SetOffStage( actor );
 765     DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
 766   }
 767
 768   END_TEST;
 769 }
 770
 771 int UtcDaliRendererFactoryGetNPatchRenderer3(void)
 772 {
 773   ToolkitTestApplication application;
 774   tet_infoline( "UtcDaliRendererFactoryGetNPatchRenderer3: Request 9-patch renderer with an image url" );
 775
 776   RendererFactory factory = RendererFactory::Get();
 777   DALI_TEST_CHECK( factory );
 778
 779   const unsigned int ninePatchImageHeight = 18;
 780   const unsigned int ninePatchImageWidth = 28;
 781   StretchRanges stretchRangesX;
 782   stretchRangesX.PushBack( Uint16Pair( 2, 3 ) );
 783   StretchRanges stretchRangesY;
 784   stretchRangesY.PushBack( Uint16Pair( 4, 5 ) );
 785   Integration::ResourcePointer ninePatchResource = CustomizeNinePatch( application, ninePatchImageWidth, ninePatchImageHeight, stretchRangesX, stretchRangesY );
 786
 787   ControlRenderer controlRenderer = factory.CreateControlRenderer( TEST_NPATCH_FILE_NAME, ImageDimensions() );
 788   DALI_TEST_CHECK( controlRenderer );
 789
 790   Actor actor = Actor::New();
 791
 792   TestGlAbstraction& gl = application.GetGlAbstraction();
 793   TraceCallStack& textureTrace = gl.GetTextureTrace();
 794   textureTrace.Enable(true);
 795
 796   TestControlRendererRender( application, actor, controlRenderer, 1u,
 797                              ImageDimensions(ninePatchImageWidth, ninePatchImageHeight),
 798                              ninePatchResource );
 799
 800   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 801
 802   END_TEST;
 803 }
 804
 805 int UtcDaliRendererFactoryGetNPatchRenderer4(void)
 806 {
 807   ToolkitTestApplication application;
 808   tet_infoline( "UtcDaliRendererFactoryGetNPatchRenderer4: Request n-patch renderer with an image url" );
 809
 810   RendererFactory factory = RendererFactory::Get();
 811   DALI_TEST_CHECK( factory );
 812
 813   const unsigned int ninePatchImageHeight = 18;
 814   const unsigned int ninePatchImageWidth = 28;
 815   StretchRanges stretchRangesX;
 816   stretchRangesX.PushBack( Uint16Pair( 2, 3 ) );
 817   stretchRangesX.PushBack( Uint16Pair( 5, 7 ) );
 818   stretchRangesX.PushBack( Uint16Pair( 12, 15 ) );
 819   StretchRanges stretchRangesY;
 820   stretchRangesY.PushBack( Uint16Pair( 4, 5 ) );
 821   stretchRangesY.PushBack( Uint16Pair( 8, 12 ) );
 822   stretchRangesY.PushBack( Uint16Pair( 15, 16 ) );
 823   stretchRangesY.PushBack( Uint16Pair( 25, 27 ) );
 824   Integration::ResourcePointer ninePatchResource = CustomizeNinePatch( application, ninePatchImageWidth, ninePatchImageHeight, stretchRangesX, stretchRangesY );
 825
 826   ControlRenderer controlRenderer = factory.CreateControlRenderer( TEST_NPATCH_FILE_NAME, ImageDimensions() );
 827   DALI_TEST_CHECK( controlRenderer );
 828
 829   Actor actor = Actor::New();
 830
 831   TestGlAbstraction& gl = application.GetGlAbstraction();
 832   TraceCallStack& textureTrace = gl.GetTextureTrace();
 833   textureTrace.Enable(true);
 834
 835   TestControlRendererRender( application, actor, controlRenderer, 1u,
 836                              ImageDimensions(ninePatchImageWidth, ninePatchImageHeight),
 837                              ninePatchResource );
 838
 839   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 840
 841   END_TEST;
 842 }
 843
 844 int UtcDaliRendererFactoryGetNPatchRendererN1(void)
 845 {
 846   //This should still load but display an error image
 847
 848   ToolkitTestApplication application;
 849   tet_infoline( "UtcDaliRendererFactoryGetNPatchRendererN: Request n-patch renderer with an invalid image url" );
 850
 851   RendererFactory factory = RendererFactory::Get();
 852   DALI_TEST_CHECK( factory );
 853
 854   ControlRenderer controlRenderer = factory.CreateControlRenderer( "ERROR.9.jpg", ImageDimensions() );
 855   DALI_TEST_CHECK( controlRenderer );
 856
 857   Actor actor = Actor::New();
 858
 859   //The testkit still has to load a bitmap for the broken renderer image
 860   Integration::Bitmap* bitmap = Integration::Bitmap::New(Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD);
 861   bitmap->GetPackedPixelsProfile()->ReserveBuffer( Pixel::RGBA8888, 100, 100, 100, 100 );
 862
 863   TestGlAbstraction& gl = application.GetGlAbstraction();
 864   TraceCallStack& textureTrace = gl.GetTextureTrace();
 865   textureTrace.Enable(true);
 866
 867   TestControlRendererRender( application, actor, controlRenderer, 1u,
 868                              ImageDimensions(),
 869                              Integration::ResourcePointer(bitmap) );
 870
 871   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 872
 873   END_TEST;
 874 }
 875
 876 int UtcDaliRendererFactoryGetNPatchRendererN2(void)
 877 {
 878   //This should still load but display an error image
 879
 880   ToolkitTestApplication application;
 881   tet_infoline( "UtcDaliRendererFactoryGetNPatchRendererN: Request n-patch renderer with an invalid Property::Map" );
 882
 883   RendererFactory factory = RendererFactory::Get();
 884   DALI_TEST_CHECK( factory );
 885
 886   Property::Map propertyMap;
 887   propertyMap.Insert( "rendererType",  111 );
 888   propertyMap.Insert( "url",  "ERROR.9.jpg" );
 889
 890   ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
 891   DALI_TEST_CHECK( controlRenderer );
 892
 893   Actor actor = Actor::New();
 894
 895   //The testkit still has to load a bitmap for the broken renderer image
 896   Integration::Bitmap* bitmap = Integration::Bitmap::New(Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD);
 897   bitmap->GetPackedPixelsProfile()->ReserveBuffer( Pixel::RGBA8888, 100, 100, 100, 100 );
 898
 899   TestGlAbstraction& gl = application.GetGlAbstraction();
 900   TraceCallStack& textureTrace = gl.GetTextureTrace();
 901   textureTrace.Enable(true);
 902
 903   TestControlRendererRender( application, actor, controlRenderer, 1u,
 904                              ImageDimensions(),
 905                              Integration::ResourcePointer(bitmap) );
 906
 907   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 908
 909   END_TEST;
 910 }
 911
 912 int UtcDaliRendererFactoryGetSvgRenderer(void)
 913 {
 914   ToolkitTestApplication application;
 915   tet_infoline( "UtcDaliRendererFactoryGetSvgRenderer: Request svg renderer with a svg url" );
 916
 917   RendererFactory factory = RendererFactory::Get();
 918   ControlRenderer controlRenderer = factory.CreateControlRenderer( TEST_SVG_FILE_NAME, ImageDimensions() );
 919   DALI_TEST_CHECK( controlRenderer );
 920
 921   TestGlAbstraction& gl = application.GetGlAbstraction();
 922   TraceCallStack& textureTrace = gl.GetTextureTrace();
 923   textureTrace.Enable(true);
 924
 925   Actor actor = Actor::New();
 926   actor.SetSize( 200.f, 200.f );
 927   Stage::GetCurrent().Add( actor );
 928   controlRenderer.SetSize( Vector2(200.f, 200.f) );
 929   controlRenderer.SetOnStage( actor );
 930   application.SendNotification();
 931   application.Render();
 932
 933   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 934
 935   EventThreadCallback* eventTrigger = EventThreadCallback::Get();
 936   CallbackBase* callback = eventTrigger->GetCallback();
 937
 938   eventTrigger->WaitingForTrigger( 1 );// waiting until the svg image is rasterized.
 939   CallbackBase::Execute( *callback );
 940
 941   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 942
 943   // waiting for the resource uploading
 944   application.SendNotification();
 945   application.Render();
 946
 947   DALI_TEST_EQUALS( textureTrace.FindMethod("BindTexture"), true, TEST_LOCATION );
 948
 949   END_TEST;
 950 }
 951
 952 //Test if mesh loads correctly when supplied with only the bare minimum requirements, an object file.
 953 int UtcDaliRendererFactoryGetMeshRenderer1(void)
 954 {
 955   ToolkitTestApplication application;
 956   tet_infoline( "UtcDaliRendererFactoryGetMeshRenderer1:  Request mesh renderer with a valid object file only" );
 957
 958   RendererFactory factory = RendererFactory::Get();
 959   DALI_TEST_CHECK( factory );
 960
 961   //Set up renderer properties.
 962   Property::Map propertyMap;
 963   propertyMap.Insert( "rendererType",  "mesh" );
 964   propertyMap.Insert( "objectUrl", TEST_OBJ_FILE_NAME );
 965
 966   ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
 967   DALI_TEST_CHECK( controlRenderer );
 968
 969   Actor actor = Actor::New();
 970   actor.SetSize( 200.f, 200.f );
 971   Stage::GetCurrent().Add( actor );
 972   controlRenderer.SetSize( Vector2( 200.f, 200.f ) );
 973   controlRenderer.SetOnStage( actor );
 974
 975   application.SendNotification();
 976   application.Render( 0 );
 977
 978   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
 979
 980   //Tell the platform abstraction that the required resources have been loaded.
 981   TestPlatformAbstraction& platform = application.GetPlatform();
 982   platform.SetAllResourceRequestsAsLoaded();
 983
 984   //Render again to upload the now-loaded textures.
 985   application.SendNotification();
 986   application.Render( 0 );
 987
 988   TestGlAbstraction& gl = application.GetGlAbstraction();
 989
 990   Matrix testScaleMatrix;
 991   testScaleMatrix.SetIdentityAndScale( Vector3( 1.0, -1.0, 1.0 ) );
 992   Matrix actualScaleMatrix;
 993
 994   //Test to see if the object has been successfully loaded.
 995   DALI_TEST_CHECK( gl.GetUniformValue<Matrix>( "uObjectMatrix", actualScaleMatrix ) );
 996   DALI_TEST_EQUALS( actualScaleMatrix, testScaleMatrix, Math::MACHINE_EPSILON_100, TEST_LOCATION );
 997
 998   controlRenderer.SetOffStage( actor );
 999   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
1000
1001   END_TEST;
1002 }
1003
1004 //Test if mesh loads correctly when supplied with an object file as well as a blank material file and images directory.
1005 int UtcDaliRendererFactoryGetMeshRenderer2(void)
1006 {
1007   ToolkitTestApplication application;
1008   tet_infoline( "UtcDaliRendererFactoryGetMeshRenderer2:  Request mesh renderer with blank material file and images directory" );
1009
1010   RendererFactory factory = RendererFactory::Get();
1011   DALI_TEST_CHECK( factory );
1012
1013   //Set up renderer properties.
1014   Property::Map propertyMap;
1015   propertyMap.Insert( "rendererType",  "mesh" );
1016   propertyMap.Insert( "objectUrl", TEST_OBJ_FILE_NAME );
1017   propertyMap.Insert( "materialUrl", "" );
1018   propertyMap.Insert( "texturesPath", "" );
1019
1020   ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
1021   DALI_TEST_CHECK( controlRenderer );
1022
1023   //Add renderer to an actor on stage.
1024   Actor actor = Actor::New();
1025   actor.SetSize( 200.f, 200.f );
1026   Stage::GetCurrent().Add( actor );
1027   controlRenderer.SetSize( Vector2( 200.f, 200.f ) );
1028   controlRenderer.SetOnStage( actor );
1029
1030   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
1031
1032   //Attempt to render to queue resource load requests.
1033   application.SendNotification();
1034   application.Render( 0 );
1035
1036   //Tell the platform abstraction that the required resources have been loaded.
1037   TestPlatformAbstraction& platform = application.GetPlatform();
1038   platform.SetAllResourceRequestsAsLoaded();
1039
1040   //Render again to upload the now-loaded textures.
1041   application.SendNotification();
1042   application.Render( 0 );
1043
1044   TestGlAbstraction& gl = application.GetGlAbstraction();
1045
1046   Matrix testScaleMatrix;
1047   testScaleMatrix.SetIdentityAndScale( Vector3( 1.0, -1.0, 1.0 ) );
1048   Matrix actualScaleMatrix;
1049
1050   //Test to see if the object has been successfully loaded.
1051   DALI_TEST_CHECK( gl.GetUniformValue<Matrix>( "uObjectMatrix", actualScaleMatrix ) );
1052   DALI_TEST_EQUALS( actualScaleMatrix, testScaleMatrix, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1053
1054   controlRenderer.SetOffStage( actor );
1055   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
1056
1057   END_TEST;
1058 }
1059
1060 //Test if mesh loads correctly when supplied with all parameters, an object file, a material file and a directory location.
1061 int UtcDaliRendererFactoryGetMeshRenderer3(void)
1062 {
1063   ToolkitTestApplication application;
1064   tet_infoline( "UtcDaliRendererFactoryGetMeshRenderer3:  Request mesh renderer with all parameters correct" );
1065
1066   RendererFactory factory = RendererFactory::Get();
1067   DALI_TEST_CHECK( factory );
1068
1069   //Set up renderer properties.
1070   Property::Map propertyMap;
1071   propertyMap.Insert( "rendererType",  "mesh" );
1072   propertyMap.Insert( "objectUrl", TEST_OBJ_FILE_NAME );
1073   propertyMap.Insert( "materialUrl", TEST_MTL_FILE_NAME );
1074   propertyMap.Insert( "texturesPath", TEST_RESOURCE_DIR "/" );
1075
1076   ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
1077   DALI_TEST_CHECK( controlRenderer );
1078
1079   //Add renderer to an actor on stage.
1080   Actor actor = Actor::New();
1081   actor.SetSize( 200.f, 200.f );
1082   Stage::GetCurrent().Add( actor );
1083   controlRenderer.SetSize( Vector2( 200.f, 200.f ) );
1084   controlRenderer.SetOnStage( actor );
1085
1086   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
1087
1088   //Attempt to render to queue resource load requests.
1089   application.SendNotification();
1090   application.Render( 0 );
1091
1092   //Tell the platform abstraction that the required resources have been loaded.
1093   TestPlatformAbstraction& platform = application.GetPlatform();
1094   platform.SetAllResourceRequestsAsLoaded();
1095
1096   //Render again to upload the now-loaded textures.
1097   application.SendNotification();
1098   application.Render( 0 );
1099
1100   TestGlAbstraction& gl = application.GetGlAbstraction();
1101
1102   Matrix testScaleMatrix;
1103   testScaleMatrix.SetIdentityAndScale( Vector3( 1.0, -1.0, 1.0 ) );
1104   Matrix actualScaleMatrix;
1105
1106   //Test to see if the object has been successfully loaded.
1107   DALI_TEST_CHECK( gl.GetUniformValue<Matrix>( "uObjectMatrix", actualScaleMatrix ) );
1108   DALI_TEST_EQUALS( actualScaleMatrix, testScaleMatrix, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1109
1110   controlRenderer.SetOffStage( actor );
1111   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
1112
1113   END_TEST;
1114 }
1115
1116 //Test if mesh renderer can load a correctly supplied mesh without a normal map or gloss map in the material file.
1117 int UtcDaliRendererFactoryGetMeshRenderer4(void)
1118 {
1119   ToolkitTestApplication application;
1120   tet_infoline( "UtcDaliRendererFactoryGetMeshRenderer4:  Request mesh renderer with diffuse texture but not normal or gloss." );
1121
1122   RendererFactory factory = RendererFactory::Get();
1123   DALI_TEST_CHECK( factory );
1124
1125   //Set up renderer properties.
1126   Property::Map propertyMap;
1127   propertyMap.Insert( "rendererType",  "mesh" );
1128   propertyMap.Insert( "objectUrl", TEST_OBJ_FILE_NAME );
1129   propertyMap.Insert( "materialUrl", TEST_SIMPLE_MTL_FILE_NAME );
1130   propertyMap.Insert( "texturesPath", TEST_RESOURCE_DIR "/" );
1131
1132   ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
1133   DALI_TEST_CHECK( controlRenderer );
1134
1135   //Add renderer to an actor on stage.
1136   Actor actor = Actor::New();
1137   actor.SetSize( 200.f, 200.f );
1138   Stage::GetCurrent().Add( actor );
1139   controlRenderer.SetSize( Vector2( 200.f, 200.f ) );
1140   controlRenderer.SetOnStage( actor );
1141
1142   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
1143
1144   //Attempt to render to queue resource load requests.
1145   application.SendNotification();
1146   application.Render( 0 );
1147
1148   //Tell the platform abstraction that the required resources have been loaded.
1149   TestPlatformAbstraction& platform = application.GetPlatform();
1150   platform.SetAllResourceRequestsAsLoaded();
1151
1152   //Render again to upload the now-loaded textures.
1153   application.SendNotification();
1154   application.Render( 0 );
1155
1156   TestGlAbstraction& gl = application.GetGlAbstraction();
1157
1158   Matrix testScaleMatrix;
1159   testScaleMatrix.SetIdentityAndScale( Vector3( 1.0, -1.0, 1.0 ) );
1160   Matrix actualScaleMatrix;
1161
1162   //Test to see if the object has been successfully loaded.
1163   DALI_TEST_CHECK( gl.GetUniformValue<Matrix>( "uObjectMatrix", actualScaleMatrix ) );
1164   DALI_TEST_EQUALS( actualScaleMatrix, testScaleMatrix, Math::MACHINE_EPSILON_100, TEST_LOCATION );
1165
1166   controlRenderer.SetOffStage( actor );
1167   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
1168
1169   END_TEST;
1170 }
1171
1172 //Test if mesh renderer handles the case of lacking an object file.
1173 int UtcDaliRendererFactoryGetMeshRendererN1(void)
1174 {
1175   ToolkitTestApplication application;
1176   tet_infoline( "UtcDaliRendererFactoryGetMeshRendererN1:  Request mesh renderer without object file" );
1177
1178   RendererFactory factory = RendererFactory::Get();
1179   DALI_TEST_CHECK( factory );
1180
1181   //Set up renderer properties.
1182   Property::Map propertyMap;
1183   propertyMap.Insert( "rendererType",  "mesh" );
1184   propertyMap.Insert( "materialUrl", TEST_MTL_FILE_NAME );
1185   propertyMap.Insert( "texturesPath", TEST_RESOURCE_DIR "/" );
1186
1187   ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
1188   DALI_TEST_CHECK( controlRenderer );
1189
1190   //Add renderer to an actor on stage.
1191   Actor actor = Actor::New();
1192   actor.SetSize( 200.f, 200.f );
1193   Stage::GetCurrent().Add( actor );
1194   controlRenderer.SetSize( Vector2( 200.f, 200.f ) );
1195   controlRenderer.SetOnStage( actor );
1196
1197   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
1198
1199   //Attempt to render to queue resource load requests.
1200   application.SendNotification();
1201   application.Render( 0 );
1202
1203   //Tell the platform abstraction that the required resources have been loaded.
1204   TestPlatformAbstraction& platform = application.GetPlatform();
1205   platform.SetAllResourceRequestsAsLoaded();
1206
1207   //Render again to upload the now-loaded textures.
1208   application.SendNotification();
1209   application.Render( 0 );
1210
1211   TestGlAbstraction& gl = application.GetGlAbstraction();
1212
1213   //Test to see if the object has not been loaded, as expected.
1214   Matrix scaleMatrix;
1215   DALI_TEST_CHECK( ! gl.GetUniformValue<Matrix>( "uObjectMatrix", scaleMatrix ) );
1216
1217   controlRenderer.SetOffStage( actor );
1218   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
1219
1220   END_TEST;
1221 }
1222
1223 //Test if mesh renderer handles the case of being passed invalid material and images urls.
1224 int UtcDaliRendererFactoryGetMeshRendererN2(void)
1225 {
1226   ToolkitTestApplication application;
1227   tet_infoline( "UtcDaliRendererFactoryGetMeshRendererN2:  Request mesh renderer with invalid material and images urls" );
1228
1229   RendererFactory factory = RendererFactory::Get();
1230   DALI_TEST_CHECK( factory );
1231
1232   //Set up renderer properties.
1233   Property::Map propertyMap;
1234   propertyMap.Insert( "rendererType",  "mesh" );
1235   propertyMap.Insert( "objectUrl", TEST_OBJ_FILE_NAME );
1236   propertyMap.Insert( "materialUrl", "invalid" );
1237   propertyMap.Insert( "texturesPath", "also invalid" );
1238
1239   ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
1240   DALI_TEST_CHECK( controlRenderer );
1241
1242   //Add renderer to an actor on stage.
1243   Actor actor = Actor::New();
1244   actor.SetSize( 200.f, 200.f );
1245   Stage::GetCurrent().Add( actor );
1246   controlRenderer.SetSize( Vector2( 200.f, 200.f ) );
1247   controlRenderer.SetOnStage( actor );
1248
1249   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
1250
1251   //Attempt to render to queue resource load requests.
1252   application.SendNotification();
1253   application.Render( 0 );
1254
1255   //Tell the platform abstraction that the required resources have been loaded.
1256   TestPlatformAbstraction& platform = application.GetPlatform();
1257   platform.SetAllResourceRequestsAsLoaded();
1258
1259   //Render again to upload the now-loaded textures.
1260   application.SendNotification();
1261   application.Render( 0 );
1262
1263   TestGlAbstraction& gl = application.GetGlAbstraction();
1264
1265   //Test to see if the object has not been loaded, as expected.
1266   Matrix scaleMatrix;
1267   DALI_TEST_CHECK( ! gl.GetUniformValue<Matrix>( "uObjectMatrix", scaleMatrix ) );
1268
1269   controlRenderer.SetOffStage( actor );
1270   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
1271
1272   END_TEST;
1273 }
1274
1275 //Test if mesh renderer handles the case of being passed an invalid object url
1276 int UtcDaliRendererFactoryGetMeshRendererN3(void)
1277 {
1278   ToolkitTestApplication application;
1279   tet_infoline( "UtcDaliRendererFactoryGetMeshRendererN3:  Request mesh renderer with invalid object url" );
1280
1281   RendererFactory factory = RendererFactory::Get();
1282   DALI_TEST_CHECK( factory );
1283
1284   //Set up renderer properties.
1285   Property::Map propertyMap;
1286   propertyMap.Insert( "rendererType",  "mesh" );
1287   propertyMap.Insert( "objectUrl", "invalid" );
1288   propertyMap.Insert( "materialUrl", TEST_MTL_FILE_NAME );
1289   propertyMap.Insert( "texturesPath", TEST_RESOURCE_DIR "/" );
1290
1291   ControlRenderer controlRenderer = factory.CreateControlRenderer( propertyMap );
1292   DALI_TEST_CHECK( controlRenderer );
1293
1294   //Add renderer to an actor on stage.
1295   Actor actor = Actor::New();
1296   actor.SetSize( 200.f, 200.f );
1297   Stage::GetCurrent().Add( actor );
1298   controlRenderer.SetSize( Vector2( 200.f, 200.f ) );
1299   controlRenderer.SetOnStage( actor );
1300
1301   DALI_TEST_CHECK( actor.GetRendererCount() == 1u );
1302
1303   //Attempt to render to queue resource load requests.
1304   application.SendNotification();
1305   application.Render( 0 );
1306
1307   //Tell the platform abstraction that the required resources have been loaded.
1308   TestPlatformAbstraction& platform = application.GetPlatform();
1309   platform.SetAllResourceRequestsAsLoaded();
1310
1311   //Render again to upload the now-loaded textures.
1312   application.SendNotification();
1313   application.Render( 0 );
1314
1315   TestGlAbstraction& gl = application.GetGlAbstraction();
1316
1317   //Test to see if the object has not been loaded, as expected.
1318   Matrix scaleMatrix;
1319   DALI_TEST_CHECK( ! gl.GetUniformValue<Matrix>( "uObjectMatrix", scaleMatrix ) );
1320
1321   controlRenderer.SetOffStage( actor );
1322   DALI_TEST_CHECK( actor.GetRendererCount() == 0u );
1323
1324   END_TEST;
1325 }