automated-tests/src/dali/utc-Dali-Texture.cpp

   1 /*
   2  * Copyright (c) 2021 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
  18 #include <dali-test-suite-utils.h>
  19 #include <dali/devel-api/images/pixel-data-devel.h>
  20 #include <dali/devel-api/rendering/texture-devel.h>
  21 #include <dali/public-api/dali-core.h>
  22 #include <test-native-image.h>
  23
  24 using namespace Dali;
  25
  26 #include <mesh-builder.h>
  27
  28 void texture_set_startup(void)
  29 {
  30   test_return_value = TET_UNDEF;
  31 }
  32
  33 void texture_set_cleanup(void)
  34 {
  35   test_return_value = TET_PASS;
  36 }
  37
  38 int UtcDaliTextureNew01(void)
  39 {
  40   TestApplication application;
  41
  42   unsigned int width(64);
  43   unsigned int height(64);
  44   Texture      texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
  45
  46   DALI_TEST_CHECK(texture);
  47   END_TEST;
  48 }
  49
  50 int UtcDaliTextureNew02(void)
  51 {
  52   TestApplication application;
  53   Texture         texture;
  54   DALI_TEST_CHECK(!texture);
  55   END_TEST;
  56 }
  57
  58 int UtcDaliTextureNew03(void)
  59 {
  60   TestApplication application;
  61
  62   // Create a native image source.
  63   TestNativeImagePointer testNativeImage = TestNativeImage::New(64u, 64u);
  64
  65   // Create a texture from the native image source.
  66   Texture nativeTexture = Texture::New(*testNativeImage);
  67
  68   // Check the texture was created OK.
  69   DALI_TEST_CHECK(nativeTexture);
  70
  71   END_TEST;
  72 }
  73
  74 int UtcDaliTextureCopyConstructor(void)
  75 {
  76   TestApplication application;
  77
  78   unsigned int width(64);
  79   unsigned int height(64);
  80   Texture      texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
  81
  82   Texture textureCopy(texture);
  83
  84   DALI_TEST_CHECK(textureCopy);
  85
  86   END_TEST;
  87 }
  88
  89 int UtcDaliTextureAssignmentOperator(void)
  90 {
  91   TestApplication application;
  92   unsigned int    width(64);
  93   unsigned int    height(64);
  94   Texture         texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
  95
  96   Texture texture2;
  97   DALI_TEST_CHECK(!texture2);
  98
  99   texture2 = texture;
 100   DALI_TEST_CHECK(texture2);
 101
 102   END_TEST;
 103 }
 104
 105 int UtcDaliTextureMoveConstructor(void)
 106 {
 107   TestApplication application;
 108
 109   uint32_t width   = 64;
 110   uint32_t height  = 64;
 111   Texture  texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
 112   DALI_TEST_CHECK(texture);
 113   DALI_TEST_EQUALS(1, texture.GetBaseObject().ReferenceCount(), TEST_LOCATION);
 114   DALI_TEST_EQUALS(texture.GetWidth(), width, TEST_LOCATION);
 115   DALI_TEST_EQUALS(texture.GetHeight(), height, TEST_LOCATION);
 116
 117   Texture move = std::move(texture);
 118   DALI_TEST_CHECK(move);
 119   DALI_TEST_EQUALS(1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
 120   DALI_TEST_EQUALS(move.GetWidth(), width, TEST_LOCATION);
 121   DALI_TEST_EQUALS(move.GetHeight(), height, TEST_LOCATION);
 122   DALI_TEST_CHECK(!texture);
 123
 124   END_TEST;
 125 }
 126
 127 int UtcDaliTextureMoveAssignment(void)
 128 {
 129   TestApplication application;
 130
 131   uint32_t width   = 64;
 132   uint32_t height  = 64;
 133   Texture  texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
 134   DALI_TEST_CHECK(texture);
 135   DALI_TEST_EQUALS(1, texture.GetBaseObject().ReferenceCount(), TEST_LOCATION);
 136   DALI_TEST_EQUALS(texture.GetWidth(), width, TEST_LOCATION);
 137   DALI_TEST_EQUALS(texture.GetHeight(), height, TEST_LOCATION);
 138
 139   Texture move;
 140   move = std::move(texture);
 141   DALI_TEST_CHECK(move);
 142   DALI_TEST_EQUALS(1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
 143   DALI_TEST_EQUALS(move.GetWidth(), width, TEST_LOCATION);
 144   DALI_TEST_EQUALS(move.GetHeight(), height, TEST_LOCATION);
 145   DALI_TEST_CHECK(!texture);
 146
 147   END_TEST;
 148 }
 149
 150 int UtcDaliTextureDownCast01(void)
 151 {
 152   TestApplication application;
 153   unsigned int    width(64);
 154   unsigned int    height(64);
 155   Texture         texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
 156
 157   BaseHandle handle(texture);
 158   Texture    texture2 = Texture::DownCast(handle);
 159   DALI_TEST_CHECK(texture2);
 160
 161   END_TEST;
 162 }
 163
 164 int UtcDaliTextureDownCast02(void)
 165 {
 166   TestApplication application;
 167
 168   Handle  handle  = Handle::New(); // Create a custom object
 169   Texture texture = Texture::DownCast(handle);
 170   DALI_TEST_CHECK(!texture);
 171   END_TEST;
 172 }
 173
 174 int UtcDaliTextureUpload01(void)
 175 {
 176   TestApplication application;
 177
 178   //Create the texture
 179   unsigned int width(64);
 180   unsigned int height(64);
 181   Texture      texture = CreateTexture(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
 182
 183   application.GetGlAbstraction().EnableTextureCallTrace(true);
 184
 185   application.SendNotification();
 186   application.Render();
 187
 188   TraceCallStack& callStack = application.GetGlAbstraction().GetTextureTrace();
 189
 190   //Upload data to the texture
 191   callStack.Reset();
 192
 193   unsigned int   bufferSize(width * height * 4);
 194   unsigned char* buffer    = reinterpret_cast<unsigned char*>(malloc(bufferSize));
 195   PixelData      pixelData = PixelData::New(buffer, bufferSize, width, height, Pixel::RGBA8888, PixelData::FREE);
 196   texture.Upload(pixelData);
 197   application.SendNotification();
 198   application.Render();
 199
 200   //TexImage2D should be called to upload the data
 201   {
 202     std::stringstream out;
 203     out << GL_TEXTURE_2D << ", " << 0u << ", " << width << ", " << height;
 204     DALI_TEST_CHECK(callStack.FindMethodAndParams("TexImage2D", out.str().c_str()));
 205   }
 206
 207   //Upload part of the texture
 208   callStack.Reset();
 209   bufferSize                  = width * height * 2;
 210   buffer                      = reinterpret_cast<unsigned char*>(malloc(bufferSize));
 211   PixelData pixelDataSubImage = PixelData::New(buffer, bufferSize, width, height, Pixel::RGBA8888, PixelData::FREE);
 212   texture.Upload(pixelDataSubImage, 0u, 0u, width / 2, height / 2, width / 2, height / 2);
 213   application.SendNotification();
 214   application.Render();
 215
 216   //TexSubImage2D should be called to upload the data
 217   {
 218     std::stringstream out;
 219     out << GL_TEXTURE_2D << ", " << 0u << ", " << width / 2 << ", " << height / 2 << ", " << width / 2 << ", " << height / 2;
 220     DALI_TEST_CHECK(callStack.FindMethodAndParams("TexSubImage2D", out.str().c_str()));
 221   }
 222
 223   END_TEST;
 224 }
 225
 226 int UtcDaliTextureUpload02(void)
 227 {
 228   TestApplication application;
 229
 230   //Create the texture
 231   unsigned int width(64);
 232   unsigned int height(64);
 233   Texture      texture = CreateTexture(TextureType::TEXTURE_CUBE, Pixel::RGBA8888, width, height);
 234
 235   application.GetGlAbstraction().EnableTextureCallTrace(true);
 236
 237   application.SendNotification();
 238   application.Render();
 239
 240   TraceCallStack& callStack = application.GetGlAbstraction().GetTextureTrace();
 241
 242   tet_infoline("TexImage2D should be called six times with a null pointer to reserve storage for the six textures of the cube map");
 243   for(unsigned int i(0); i < 6; ++i)
 244   {
 245     std::stringstream out;
 246     out << GL_TEXTURE_CUBE_MAP_POSITIVE_X + i << ", " << 0u << ", " << width << ", " << height;
 247     DALI_TEST_CHECK(callStack.FindMethodAndParams("TexImage2D", out.str().c_str()));
 248   }
 249
 250   unsigned int   bufferSize(width * height * 4);
 251   unsigned char* buffer    = reinterpret_cast<unsigned char*>(malloc(bufferSize));
 252   PixelData      pixelData = PixelData::New(buffer, bufferSize, width, height, Pixel::RGBA8888, PixelData::FREE);
 253
 254   //Upload data to the POSITIVE_X face of the texture
 255   {
 256     callStack.Reset();
 257
 258     texture.Upload(pixelData, CubeMapLayer::POSITIVE_X, 0u, 0u, 0u, width, height);
 259     application.SendNotification();
 260     application.Render();
 261
 262     //TexImage2D should be called to upload the data to the POSITIVE_X face
 263     {
 264       std::stringstream out;
 265       out << GL_TEXTURE_CUBE_MAP_POSITIVE_X << ", " << 0u << ", " << width << ", " << height;
 266       DALI_TEST_CHECK(callStack.FindMethodAndParams("TexImage2D", out.str().c_str()));
 267     }
 268   }
 269
 270   //Upload data to the NEGATIVE_X face of the texture
 271   {
 272     callStack.Reset();
 273
 274     texture.Upload(pixelData, CubeMapLayer::NEGATIVE_X, 0u, 0u, 0u, width, height);
 275     application.SendNotification();
 276     application.Render();
 277
 278     //TexImage2D should be called to upload the data to the NEGATIVE_X face
 279     {
 280       std::stringstream out;
 281       out << GL_TEXTURE_CUBE_MAP_NEGATIVE_X << ", " << 0u << ", " << width << ", " << height;
 282       DALI_TEST_CHECK(callStack.FindMethodAndParams("TexImage2D", out.str().c_str()));
 283     }
 284   }
 285
 286   //Upload data to the POSITIVE_Y face of the texture
 287   {
 288     callStack.Reset();
 289     texture.Upload(pixelData, CubeMapLayer::POSITIVE_Y, 0u, 0u, 0u, width, height);
 290     application.SendNotification();
 291     application.Render();
 292
 293     //TexImage2D should be called to upload the data to the POSITIVE_Y face
 294     {
 295       std::stringstream out;
 296       out << GL_TEXTURE_CUBE_MAP_POSITIVE_Y << ", " << 0u << ", " << width << ", " << height;
 297       DALI_TEST_CHECK(callStack.FindMethodAndParams("TexImage2D", out.str().c_str()));
 298     }
 299   }
 300
 301   //Upload data to the NEGATIVE_Y face of the texture
 302   {
 303     callStack.Reset();
 304     texture.Upload(pixelData, CubeMapLayer::NEGATIVE_Y, 0u, 0u, 0u, width, height);
 305     application.SendNotification();
 306     application.Render();
 307
 308     //TexImage2D should be called to upload the data to the NEGATIVE_Y face
 309     {
 310       std::stringstream out;
 311       out << GL_TEXTURE_CUBE_MAP_NEGATIVE_Y << ", " << 0u << ", " << width << ", " << height;
 312       DALI_TEST_CHECK(callStack.FindMethodAndParams("TexImage2D", out.str().c_str()));
 313     }
 314   }
 315
 316   //Upload data to the POSITIVE_Z face of the texture
 317   {
 318     callStack.Reset();
 319     texture.Upload(pixelData, CubeMapLayer::POSITIVE_Z, 0u, 0u, 0u, width, height);
 320     application.SendNotification();
 321     application.Render();
 322
 323     //TexImage2D should be called to upload the data to the POSITIVE_Z face
 324     {
 325       std::stringstream out;
 326       out << GL_TEXTURE_CUBE_MAP_POSITIVE_Z << ", " << 0u << ", " << width << ", " << height;
 327       DALI_TEST_CHECK(callStack.FindMethodAndParams("TexImage2D", out.str().c_str()));
 328     }
 329   }
 330
 331   //Upload data to the NEGATIVE_Z face of the texture
 332   {
 333     callStack.Reset();
 334     texture.Upload(pixelData, CubeMapLayer::NEGATIVE_Z, 0u, 0u, 0u, width, height);
 335     application.SendNotification();
 336     application.Render();
 337
 338     //TexImage2D should be called to upload the data to the NEGATIVE_Z face
 339     {
 340       std::stringstream out;
 341       out << GL_TEXTURE_CUBE_MAP_NEGATIVE_Z << ", " << 0u << ", " << width << ", " << height;
 342       DALI_TEST_CHECK(callStack.FindMethodAndParams("TexImage2D", out.str().c_str()));
 343     }
 344   }
 345
 346   END_TEST;
 347 }
 348
 349 int UtcDaliTextureUpload03(void)
 350 {
 351   TestApplication application;
 352
 353   //Create the texture
 354   unsigned int width(64);
 355   unsigned int height(64);
 356   unsigned int widthMipmap1(32);
 357   unsigned int heightMipmap1(32);
 358
 359   Texture texture = CreateTexture(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
 360
 361   application.GetGlAbstraction().EnableTextureCallTrace(true);
 362
 363   application.SendNotification();
 364   application.Render();
 365
 366   TraceCallStack& callStack = application.GetGlAbstraction().GetTextureTrace();
 367
 368   tet_infoline("TexImage2D should be called with a null pointer to reserve storage for the texture in the gpu");
 369   {
 370     std::stringstream out;
 371     out << GL_TEXTURE_2D << ", " << 0u << ", " << width << ", " << height;
 372     DALI_TEST_CHECK(callStack.FindMethodAndParams("TexImage2D", out.str().c_str()));
 373   }
 374
 375   //Upload data to the texture mipmap 0 and mipmap 1
 376   callStack.Reset();
 377
 378   unsigned int   bufferSize(width * height * 4);
 379   unsigned char* buffer    = reinterpret_cast<unsigned char*>(malloc(bufferSize));
 380   PixelData      pixelData = PixelData::New(buffer, bufferSize, width, height, Pixel::RGBA8888, PixelData::FREE);
 381   texture.Upload(pixelData, 0u, 0u, 0u, 0u, width, height);
 382
 383   bufferSize                 = widthMipmap1 * heightMipmap1 * 4;
 384   buffer                     = reinterpret_cast<unsigned char*>(malloc(bufferSize));
 385   PixelData pixelDataMipmap1 = PixelData::New(buffer, bufferSize, width, height, Pixel::RGBA8888, PixelData::FREE);
 386   texture.Upload(pixelDataMipmap1, 0u, 1u, 0u, 0u, widthMipmap1, heightMipmap1);
 387   application.SendNotification();
 388   application.Render();
 389
 390   //TexImage2D should be called to upload the data to mipmaps 0 and 1
 391   {
 392     std::stringstream out;
 393     out << GL_TEXTURE_2D << ", " << 0u << ", " << width << ", " << height;
 394     DALI_TEST_CHECK(callStack.FindMethodAndParams("TexImage2D", out.str().c_str()));
 395   }
 396   {
 397     std::stringstream out;
 398     out << GL_TEXTURE_2D << ", " << 1u << ", " << widthMipmap1 << ", " << heightMipmap1;
 399     DALI_TEST_CHECK(callStack.FindMethodAndParams("TexImage2D", out.str().c_str()));
 400   }
 401
 402   END_TEST;
 403 }
 404
 405 int UtcDaliTextureUpload04(void)
 406 {
 407   TestApplication application;
 408
 409   //Create the texture
 410   unsigned int width(64);
 411   unsigned int height(64);
 412   unsigned int widthMipmap1(32);
 413   unsigned int heightMipmap1(32);
 414
 415   Texture texture = CreateTexture(TextureType::TEXTURE_CUBE, Pixel::RGBA8888, width, height);
 416
 417   application.GetGlAbstraction().EnableTextureCallTrace(true);
 418   TraceCallStack& callStack = application.GetGlAbstraction().GetTextureTrace();
 419
 420   //Upload data to the NEGATIVE_X face mipmap 0 and mipmap 1
 421   unsigned int   bufferSize(width * height * 4);
 422   unsigned char* buffer    = reinterpret_cast<unsigned char*>(malloc(bufferSize));
 423   PixelData      pixelData = PixelData::New(buffer, bufferSize, width, height, Pixel::RGBA8888, PixelData::FREE);
 424   texture.Upload(pixelData, CubeMapLayer::NEGATIVE_X, 0u, 0u, 0u, width, height);
 425
 426   bufferSize                 = widthMipmap1 * heightMipmap1 * 4;
 427   buffer                     = reinterpret_cast<unsigned char*>(malloc(bufferSize));
 428   PixelData pixelDataMipmap1 = PixelData::New(buffer, bufferSize, width, height, Pixel::RGBA8888, PixelData::FREE);
 429   texture.Upload(pixelDataMipmap1, CubeMapLayer::NEGATIVE_X, 1u, 0u, 0u, widthMipmap1, heightMipmap1);
 430   application.SendNotification();
 431   application.Render();
 432
 433   //TexImage2D should be called to upload the data to mipmaps 0 and 1
 434   {
 435     std::stringstream out;
 436     out << GL_TEXTURE_CUBE_MAP_NEGATIVE_X << ", " << 0u << ", " << width << ", " << height;
 437     DALI_TEST_CHECK(callStack.FindMethodAndParams("TexImage2D", out.str().c_str()));
 438   }
 439   {
 440     std::stringstream out;
 441     out << GL_TEXTURE_CUBE_MAP_NEGATIVE_X << ", " << 1u << ", " << widthMipmap1 << ", " << heightMipmap1;
 442     DALI_TEST_CHECK(callStack.FindMethodAndParams("TexImage2D", out.str().c_str()));
 443   }
 444
 445   END_TEST;
 446 }
 447
 448 int UtcDaliTextureUpload05(void)
 449 {
 450   Pixel::Format COMPRESSED_PIXEL_FORMATS[] =
 451     {
 452       Pixel::COMPRESSED_R11_EAC,
 453       Pixel::COMPRESSED_SIGNED_R11_EAC,
 454       Pixel::COMPRESSED_RG11_EAC,
 455       Pixel::COMPRESSED_SIGNED_RG11_EAC,
 456       Pixel::COMPRESSED_RGB8_ETC2,
 457       Pixel::COMPRESSED_SRGB8_ETC2,
 458       Pixel::COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2,
 459       Pixel::COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2,
 460       Pixel::COMPRESSED_RGBA8_ETC2_EAC,
 461       Pixel::COMPRESSED_SRGB8_ALPHA8_ETC2_EAC,
 462       Pixel::COMPRESSED_RGB8_ETC1,
 463       Pixel::COMPRESSED_RGB_PVRTC_4BPPV1,
 464       Pixel::COMPRESSED_RGBA_ASTC_4x4_KHR,
 465       Pixel::COMPRESSED_RGBA_ASTC_5x4_KHR,
 466       Pixel::COMPRESSED_RGBA_ASTC_5x5_KHR,
 467       Pixel::COMPRESSED_RGBA_ASTC_6x5_KHR,
 468       Pixel::COMPRESSED_RGBA_ASTC_6x6_KHR,
 469       Pixel::COMPRESSED_RGBA_ASTC_8x5_KHR,
 470       Pixel::COMPRESSED_RGBA_ASTC_8x6_KHR,
 471       Pixel::COMPRESSED_RGBA_ASTC_8x8_KHR,
 472       Pixel::COMPRESSED_RGBA_ASTC_10x5_KHR,
 473       Pixel::COMPRESSED_RGBA_ASTC_10x6_KHR,
 474       Pixel::COMPRESSED_RGBA_ASTC_10x8_KHR,
 475       Pixel::COMPRESSED_RGBA_ASTC_10x10_KHR,
 476       Pixel::COMPRESSED_RGBA_ASTC_12x10_KHR,
 477       Pixel::COMPRESSED_RGBA_ASTC_12x12_KHR,
 478       Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR,
 479       Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR,
 480       Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR,
 481       Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR,
 482       Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR,
 483       Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR,
 484       Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR,
 485       Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR,
 486       Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR,
 487       Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR,
 488       Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR,
 489       Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR,
 490       Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR,
 491       Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR,
 492     };
 493   const unsigned int NUMBER_OF_COMPRESSED_PIXEL_FORMATS = sizeof(COMPRESSED_PIXEL_FORMATS) / sizeof(Pixel::Format);
 494
 495   for(unsigned int index = 0; index < NUMBER_OF_COMPRESSED_PIXEL_FORMATS; ++index)
 496   {
 497     TestApplication application;
 498
 499     //Create a texture with a compressed format
 500     unsigned int width(64);
 501     unsigned int height(64);
 502     Texture      texture = CreateTexture(TextureType::TEXTURE_2D, COMPRESSED_PIXEL_FORMATS[index], width, height);
 503
 504     application.GetGlAbstraction().EnableTextureCallTrace(true);
 505
 506     application.SendNotification();
 507     application.Render();
 508
 509     TraceCallStack& callStack = application.GetGlAbstraction().GetTextureTrace();
 510
 511     tet_infoline("CompressedTexImage2D should be called with a null pointer to reserve storage for the texture in the gpu");
 512     {
 513       std::stringstream out;
 514       out << GL_TEXTURE_2D << ", " << 0u << ", " << width << ", " << height;
 515       DALI_TEST_CHECK(callStack.FindMethodAndParams("CompressedTexImage2D", out.str().c_str()));
 516     }
 517
 518     //Upload data to the texture
 519     callStack.Reset();
 520
 521     unsigned int   bufferSize(width * height * 4);
 522     unsigned char* buffer    = reinterpret_cast<unsigned char*>(malloc(bufferSize));
 523     PixelData      pixelData = PixelData::New(buffer, bufferSize, width, height, COMPRESSED_PIXEL_FORMATS[index], PixelData::FREE);
 524     texture.Upload(pixelData);
 525     application.SendNotification();
 526     application.Render();
 527
 528     //CompressedTexImage2D should be called to upload the data
 529     {
 530       std::stringstream out;
 531       out << GL_TEXTURE_2D << ", " << 0u << ", " << width << ", " << height;
 532       DALI_TEST_CHECK(callStack.FindMethodAndParams("CompressedTexImage2D", out.str().c_str()));
 533     }
 534
 535     //Upload part of the texture
 536     callStack.Reset();
 537     bufferSize                  = width * height * 2;
 538     buffer                      = reinterpret_cast<unsigned char*>(malloc(bufferSize));
 539     PixelData pixelDataSubImage = PixelData::New(buffer, bufferSize, width, height, COMPRESSED_PIXEL_FORMATS[index], PixelData::FREE);
 540     texture.Upload(pixelDataSubImage, 0u, 0u, width / 2, height / 2, width / 2, height / 2);
 541     application.SendNotification();
 542     application.Render();
 543
 544     //CompressedTexSubImage2D should be called to upload the data
 545     {
 546       std::stringstream out;
 547       out << GL_TEXTURE_2D << ", " << 0u << ", " << width / 2 << ", " << height / 2 << ", " << width / 2 << ", " << height / 2;
 548       DALI_TEST_CHECK(callStack.FindMethodAndParams("CompressedTexSubImage2D", out.str().c_str()));
 549     }
 550
 551     application.GetGlAbstraction().ResetTextureCallStack();
 552   }
 553
 554   END_TEST;
 555 }
 556
 557 int UtcDaliTextureUpload06(void)
 558 {
 559   TestApplication application;
 560
 561   //Create the texture
 562   unsigned int width(64);
 563   unsigned int height(64);
 564   tet_infoline("Creating a Texure with an alpha channel");
 565   Texture texture = CreateTexture(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
 566
 567   application.GetGlAbstraction().EnableTextureCallTrace(true);
 568
 569   application.SendNotification();
 570   application.Render();
 571
 572   TraceCallStack& callStack = application.GetGlAbstraction().GetTextureTrace();
 573
 574   tet_infoline("TexImage2D should be called with a null pointer to reserve storage for the texture in the gpu");
 575   {
 576     std::stringstream out;
 577     out << GL_TEXTURE_2D << ", " << 0u << ", " << width << ", " << height;
 578     DALI_TEST_CHECK(callStack.FindMethodAndParams("TexImage2D", out.str().c_str()));
 579   }
 580
 581   tet_infoline("Upload data to the texture");
 582   callStack.Reset();
 583
 584   tet_infoline("Creating a RGB pixel buffer and adding that to the texture to ensure it is handled correctly");
 585   unsigned int   bufferSize(width * height * 3);
 586   unsigned char* buffer    = reinterpret_cast<unsigned char*>(malloc(bufferSize));
 587   PixelData      pixelData = PixelData::New(buffer, bufferSize, width, height, Pixel::RGB888, PixelData::FREE);
 588   texture.Upload(pixelData);
 589   application.SendNotification();
 590   application.Render();
 591
 592   tet_infoline("TexImage2D should be called to upload the data");
 593   {
 594     std::stringstream out;
 595     out << GL_TEXTURE_2D << ", " << 0u << ", " << width << ", " << height;
 596     DALI_TEST_CHECK(callStack.FindMethodAndParams("TexImage2D", out.str().c_str()));
 597   }
 598
 599   END_TEST;
 600 }
 601
 602 int UtcDaliTextureUpload07(void)
 603 {
 604   Pixel::Format FLOATING_POINT_PIXEL_FORMATS[] =
 605     {
 606       Pixel::RGB16F,
 607       Pixel::RGB32F,
 608     };
 609   const unsigned int NUMBER_OF_FLOATING_POINT_PIXEL_FORMATS = sizeof(FLOATING_POINT_PIXEL_FORMATS) / sizeof(Pixel::Format);
 610
 611   for(unsigned int index = 0; index < NUMBER_OF_FLOATING_POINT_PIXEL_FORMATS; ++index)
 612   {
 613     TestApplication application;
 614
 615     //Create the texture
 616     unsigned int width(64);
 617     unsigned int height(64);
 618     tet_infoline("Creating a floating point texture");
 619     Texture texture = CreateTexture(TextureType::TEXTURE_2D, FLOATING_POINT_PIXEL_FORMATS[index], width, height);
 620
 621     application.GetGlAbstraction().EnableTextureCallTrace(true);
 622
 623     application.SendNotification();
 624     application.Render();
 625
 626     TraceCallStack& callStack = application.GetGlAbstraction().GetTextureTrace();
 627
 628     tet_infoline("TexImage2D should be called with a null pointer to reserve storage for the texture in the gpu");
 629     {
 630       std::stringstream out;
 631       out << GL_TEXTURE_2D << ", " << 0u << ", " << width << ", " << height;
 632       DALI_TEST_CHECK(callStack.FindMethodAndParams("TexImage2D", out.str().c_str()));
 633     }
 634
 635     tet_infoline("Upload data to the texture");
 636     callStack.Reset();
 637
 638     tet_infoline("Creating a RGB pixel buffer and adding that to the texture to ensure it is handled correctly");
 639     unsigned int   bufferSize(width * height * 3);
 640     unsigned char* buffer    = reinterpret_cast<unsigned char*>(malloc(bufferSize));
 641     PixelData      pixelData = PixelData::New(buffer, bufferSize, width, height, FLOATING_POINT_PIXEL_FORMATS[index], PixelData::FREE);
 642     texture.Upload(pixelData);
 643     application.SendNotification();
 644     application.Render();
 645
 646     tet_infoline("TexImage2D should be called to upload the data");
 647     {
 648       std::stringstream out;
 649       out << GL_TEXTURE_2D << ", " << 0u << ", " << width << ", " << height;
 650       DALI_TEST_CHECK(callStack.FindMethodAndParams("TexImage2D", out.str().c_str()));
 651     }
 652   }
 653
 654   END_TEST;
 655 }
 656
 657 int UtcDaliTextureUploadPixelFormats(void)
 658 {
 659   TestApplication application;
 660   application.GetGlAbstraction().EnableTextureCallTrace(true);
 661
 662   //Create the texture
 663   unsigned int width(64);
 664   unsigned int height(64);
 665
 666   std::vector<Pixel::Format> formats =
 667     {
 668       Pixel::A8,
 669       Pixel::L8,
 670       Pixel::LA88,
 671       Pixel::RGB565,
 672       Pixel::BGR565,
 673       Pixel::RGBA4444,
 674       Pixel::BGRA4444,
 675       Pixel::RGBA5551,
 676       Pixel::BGRA5551,
 677       Pixel::RGB888,
 678       Pixel::RGB8888,
 679       Pixel::BGR8888,
 680       Pixel::RGBA8888,
 681       Pixel::BGRA8888,
 682       Pixel::DEPTH_UNSIGNED_INT,
 683       Pixel::DEPTH_FLOAT,
 684       Pixel::DEPTH_STENCIL,
 685       Pixel::RGB16F,
 686       Pixel::RGB32F,
 687       Pixel::R11G11B10F,
 688     };
 689
 690   for(auto format : formats)
 691   {
 692     tet_infoline("Creating a Texure with a new or recent format");
 693     Texture texture = CreateTexture(TextureType::TEXTURE_2D, format, width, height);
 694
 695     application.SendNotification();
 696     application.Render();
 697
 698     TraceCallStack& callStack = application.GetGlAbstraction().GetTextureTrace();
 699
 700     tet_infoline("TexImage2D should be called twice per texture");
 701     DALI_TEST_EQUALS(callStack.CountMethod("TexImage2D"), 2, TEST_LOCATION);
 702     {
 703       std::stringstream out;
 704       out << GL_TEXTURE_2D << ", " << 0u << ", " << width << ", " << height;
 705       DALI_TEST_CHECK(callStack.FindMethodAndParams("TexImage2D", out.str().c_str()));
 706     }
 707     callStack.Reset();
 708   }
 709
 710   END_TEST;
 711 }
 712
 713 int UtcDaliTextureUploadSmallerThanSize(void)
 714 {
 715   TestApplication application;
 716
 717   //Create the texture
 718   unsigned int width(64);
 719   unsigned int height(64);
 720   Texture      texture = CreateTexture(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
 721
 722   application.GetGlAbstraction().EnableTextureCallTrace(true);
 723
 724   application.SendNotification();
 725   application.Render();
 726
 727   TraceCallStack& callStack = application.GetGlAbstraction().GetTextureTrace();
 728   callStack.EnableLogging(true);
 729   TraceCallStack& texParamCallStack = application.GetGlAbstraction().GetTexParameterTrace();
 730   texParamCallStack.EnableLogging(true);
 731
 732   tet_infoline("TexImage2D should be called with a null pointer to reserve storage for the texture in the gpu");
 733   {
 734     std::stringstream out;
 735     out << GL_TEXTURE_2D << ", " << 0u << ", " << width << ", " << height;
 736     std::string params;
 737     DALI_TEST_CHECK(callStack.FindMethodAndGetParameters("TexImage2D", params));
 738     DALI_TEST_EQUALS(out.str(), params, TEST_LOCATION);
 739   }
 740
 741   //Upload data to the texture
 742   callStack.Reset();
 743
 744   unsigned int   bufferSize(width * height * 4);
 745   unsigned char* buffer    = reinterpret_cast<unsigned char*>(malloc(bufferSize));
 746   PixelData      pixelData = PixelData::New(buffer, bufferSize, width / 2, height / 2, Pixel::RGBA8888, PixelData::FREE);
 747   texture.Upload(pixelData);
 748   application.SendNotification();
 749   application.Render();
 750
 751   //TexSubImage2D should be called to upload the data
 752   {
 753     std::stringstream out;
 754     out << GL_TEXTURE_2D << ", " << 0u << ", " << 0u << ", " << 0u << ", " << width / 2 << ", " << height / 2;
 755     std::string params;
 756     DALI_TEST_CHECK(callStack.FindMethodAndGetParameters("TexSubImage2D", params));
 757     DALI_TEST_EQUALS(out.str(), params, TEST_LOCATION);
 758   }
 759   END_TEST;
 760 }
 761
 762 int UtcDaliTextureGenerateMipmaps(void)
 763 {
 764   TestApplication application;
 765   unsigned int    width(64);
 766   unsigned int    height(64);
 767
 768   Texture texture = CreateTexture(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
 769   texture.GenerateMipmaps();
 770
 771   Texture textureCubemap = CreateTexture(TextureType::TEXTURE_CUBE, Pixel::RGBA8888, width, height);
 772   textureCubemap.GenerateMipmaps();
 773
 774   application.GetGlAbstraction().EnableTextureCallTrace(true);
 775   TraceCallStack& callStack = application.GetGlAbstraction().GetTextureTrace();
 776   application.SendNotification();
 777   application.Render();
 778
 779   {
 780     std::stringstream out;
 781     out << GL_TEXTURE_2D;
 782     DALI_TEST_CHECK(callStack.FindMethodAndParams("GenerateMipmap", out.str().c_str()));
 783   }
 784   {
 785     std::stringstream out;
 786     out << GL_TEXTURE_CUBE_MAP;
 787     DALI_TEST_CHECK(callStack.FindMethodAndParams("GenerateMipmap", out.str().c_str()));
 788   }
 789
 790   END_TEST;
 791 }
 792
 793 int UtcDaliTextureGetWidth(void)
 794 {
 795   TestApplication application;
 796   unsigned int    width(64);
 797   unsigned int    height(64);
 798
 799   Texture texture = CreateTexture(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
 800   DALI_TEST_EQUALS(texture.GetWidth(), width, TEST_LOCATION);
 801   END_TEST;
 802 }
 803
 804 int UtcDaliTextureGetHeight(void)
 805 {
 806   TestApplication application;
 807   unsigned int    width(64);
 808   unsigned int    height(64);
 809
 810   Texture texture = CreateTexture(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
 811   DALI_TEST_EQUALS(texture.GetHeight(), height, TEST_LOCATION);
 812
 813   END_TEST;
 814 }
 815
 816 int UtcDaliTextureContextLoss(void)
 817 {
 818   tet_infoline("UtcDaliTextureContextLoss\n");
 819   TestApplication application;
 820
 821   //Create the texture
 822   unsigned int width(64);
 823   unsigned int height(64);
 824   Texture      texture = CreateTexture(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
 825   DALI_TEST_CHECK(texture);
 826
 827   application.SendNotification();
 828   application.Render(16);
 829
 830   // Lose & regain context (in render 'thread')
 831   application.ResetContext();
 832   DALI_TEST_CHECK(texture);
 833
 834   END_TEST;
 835 }
 836
 837 int UtcDaliNativeImageTexture01(void)
 838 {
 839   TestApplication application;
 840   tet_infoline("UtcDaliNativeImageTexture01");
 841
 842   TestNativeImagePointer imageInterface = TestNativeImage::New(16, 16);
 843   {
 844     Texture texture = Texture::New(*(imageInterface.Get()));
 845     Actor   actor   = CreateRenderableActor(texture, "", "");
 846     application.GetScene().Add(actor);
 847
 848     DALI_TEST_CHECK(texture);
 849
 850     application.SendNotification();
 851     application.Render(16);
 852
 853     DALI_TEST_EQUALS(imageInterface->mExtensionCreateCalls, 1, TEST_LOCATION);
 854     DALI_TEST_EQUALS(imageInterface->mExtensionDestroyCalls, 0, TEST_LOCATION);
 855     DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::SIZE), Property::Value(Vector3(16, 16, 0)), TEST_LOCATION);
 856
 857     UnparentAndReset(actor);
 858
 859     application.SendNotification();
 860     application.Render(16);
 861   }
 862   application.SendNotification();
 863   application.Render(16);
 864
 865   DALI_TEST_EQUALS(imageInterface->mExtensionCreateCalls, 1, TEST_LOCATION);
 866   DALI_TEST_EQUALS(imageInterface->mExtensionDestroyCalls, 1, TEST_LOCATION);
 867
 868   END_TEST;
 869 }
 870
 871 int UtcDaliNativeImageTexture02(void)
 872 {
 873   TestApplication application;
 874   tet_infoline("UtcDaliNativeImageTexture02 - test error on TargetTexture");
 875
 876   TestNativeImagePointer imageInterface = TestNativeImage::New(16, 16);
 877   imageInterface->mTargetTextureError   = 1u;
 878   {
 879     Texture texture = Texture::New(*(imageInterface.Get()));
 880     Actor   actor   = CreateRenderableActor(texture, "", "");
 881     application.GetScene().Add(actor);
 882
 883     DALI_TEST_CHECK(texture);
 884
 885     application.SendNotification();
 886     application.Render(16);
 887
 888     // Expect 2 attempts to create the texture - once when adding the texture
 889     // to the scene-graph, and again since that failed, during the Bind.
 890     // The second one succeeds (TargetTexture only errors once)
 891     DALI_TEST_EQUALS(imageInterface->mExtensionCreateCalls, 2, TEST_LOCATION);
 892     DALI_TEST_EQUALS(imageInterface->mExtensionDestroyCalls, 1, TEST_LOCATION);
 893
 894     UnparentAndReset(actor);
 895
 896     application.SendNotification();
 897     application.Render(16);
 898   }
 899   application.SendNotification();
 900   application.Render(16);
 901
 902   // Expect that there are no further calls to create/destroy resource
 903   DALI_TEST_EQUALS(imageInterface->mExtensionCreateCalls, 2, TEST_LOCATION);
 904   DALI_TEST_EQUALS(imageInterface->mExtensionDestroyCalls, 2, TEST_LOCATION);
 905
 906   END_TEST;
 907 }
 908
 909 int UtcDaliTextureGenerateMipmapsNegative(void)
 910 {
 911   TestApplication application;
 912   Dali::Texture   instance;
 913   try
 914   {
 915     instance.GenerateMipmaps();
 916     DALI_TEST_CHECK(false); // Should not get here
 917   }
 918   catch(...)
 919   {
 920     DALI_TEST_CHECK(true); // We expect an assert
 921   }
 922   END_TEST;
 923 }
 924
 925 int UtcDaliTextureUploadNegative01(void)
 926 {
 927   TestApplication application;
 928   Dali::Texture   instance;
 929   try
 930   {
 931     Dali::PixelData arg1;
 932     instance.Upload(arg1);
 933     DALI_TEST_CHECK(false); // Should not get here
 934   }
 935   catch(...)
 936   {
 937     DALI_TEST_CHECK(true); // We expect an assert
 938   }
 939   END_TEST;
 940 }
 941
 942 int UtcDaliTextureUploadNegative02(void)
 943 {
 944   TestApplication application;
 945   Dali::Texture   instance;
 946   try
 947   {
 948     Dali::PixelData arg1;
 949     unsigned int    arg2(0u);
 950     unsigned int    arg3(0u);
 951     unsigned int    arg4(0u);
 952     unsigned int    arg5(0u);
 953     unsigned int    arg6(0u);
 954     unsigned int    arg7(0u);
 955     instance.Upload(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
 956     DALI_TEST_CHECK(false); // Should not get here
 957   }
 958   catch(...)
 959   {
 960     DALI_TEST_CHECK(true); // We expect an assert
 961   }
 962   END_TEST;
 963 }
 964
 965 int UtcDaliTextureGetWidthNegative(void)
 966 {
 967   TestApplication application;
 968   Dali::Texture   instance;
 969   try
 970   {
 971     instance.GetWidth();
 972     DALI_TEST_CHECK(false); // Should not get here
 973   }
 974   catch(...)
 975   {
 976     DALI_TEST_CHECK(true); // We expect an assert
 977   }
 978   END_TEST;
 979 }
 980
 981 int UtcDaliTextureGetHeightNegative(void)
 982 {
 983   TestApplication application;
 984   Dali::Texture   instance;
 985   try
 986   {
 987     instance.GetHeight();
 988     DALI_TEST_CHECK(false); // Should not get here
 989   }
 990   catch(...)
 991   {
 992     DALI_TEST_CHECK(true); // We expect an assert
 993   }
 994   END_TEST;
 995 }
 996
 997 int UtcDaliTextureCheckNativeP(void)
 998 {
 999   TestApplication        application;
1000   TestNativeImagePointer testNativeImage = TestNativeImage::New(64u, 64u);
1001   Texture                nativeTexture   = Texture::New(*testNativeImage);
1002
1003   DALI_TEST_CHECK(nativeTexture);
1004   DALI_TEST_CHECK(DevelTexture::IsNative(nativeTexture));
1005   END_TEST;
1006 }
1007
1008 int UtcDaliTextureCheckNativeN1(void)
1009 {
1010   TestApplication application;
1011   unsigned int    width(64);
1012   unsigned int    height(64);
1013   Texture         texture = CreateTexture(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
1014
1015   DALI_TEST_CHECK(texture);
1016   DALI_TEST_CHECK(!DevelTexture::IsNative(texture));
1017   END_TEST;
1018 }
1019
1020 int UtcDaliTextureCheckNativeN2(void)
1021 {
1022   TestApplication application;
1023   Texture         texture;
1024   try
1025   {
1026     bool native = DevelTexture::IsNative(texture);
1027     DALI_TEST_CHECK(native != native);
1028   }
1029   catch(...)
1030   {
1031     DALI_TEST_CHECK(true);
1032   }
1033   END_TEST;
1034 }
1035
1036 int UtcDaliTextureApplyFragShaderP1(void)
1037 {
1038   TestApplication        application;
1039   TestNativeImagePointer testNativeImage = TestNativeImage::New(64u, 64u);
1040   Texture                nativeTexture   = Texture::New(*testNativeImage);
1041   DALI_TEST_CHECK(nativeTexture);
1042
1043   const std::string baseFragShader =
1044     "varying mediump vec4 uColor;\n"
1045     "void main(){\n"
1046     "  gl_FragColor=uColor;\n"
1047     "}\n";
1048   std::string fragShader = baseFragShader;
1049   bool        applied    = DevelTexture::ApplyNativeFragmentShader(nativeTexture, fragShader);
1050
1051   std::string fragPrefix = "#extension GL_OES_EGL_image_external:require\n";
1052
1053   DALI_TEST_CHECK(applied);
1054   DALI_TEST_CHECK(baseFragShader.compare(fragShader));
1055   DALI_TEST_CHECK(fragShader.compare(fragPrefix + baseFragShader) == 0);
1056   DALI_TEST_CHECK(!fragShader.empty());
1057   END_TEST;
1058 }
1059
1060 int UtcDaliTextureApplyFragShaderP2(void)
1061 {
1062   TestApplication        application;
1063   TestNativeImagePointer testNativeImage = TestNativeImage::New(64u, 64u);
1064   Texture                nativeTexture   = Texture::New(*testNativeImage);
1065   DALI_TEST_CHECK(nativeTexture);
1066
1067   const std::string baseFragShader =
1068     "varying mediump vec4 uColor;\n"
1069     "varying vec2 vTexCoord;\n"
1070     "uniform sampler2D uNative;\n"
1071     "void main(){\n"
1072     "  gl_FragColor=uColor*texture2D(uNative, vTexCoord);\n"
1073     "}\n";
1074   std::string fragShader = baseFragShader;
1075   bool        applied    = DevelTexture::ApplyNativeFragmentShader(nativeTexture, fragShader);
1076
1077   DALI_TEST_CHECK(applied);
1078   DALI_TEST_CHECK(baseFragShader.compare(fragShader));
1079   DALI_TEST_CHECK(!fragShader.empty());
1080   DALI_TEST_CHECK(fragShader.find("samplerExternalOES") < fragShader.length());
1081   END_TEST;
1082 }
1083
1084 int UtcDaliTextureApplyFragShaderN1(void)
1085 {
1086   TestApplication        application;
1087   TestNativeImagePointer testNativeImage = TestNativeImage::New(64u, 64u);
1088   Texture                nativeTexture   = Texture::New(*testNativeImage);
1089   DALI_TEST_CHECK(nativeTexture);
1090
1091   std::string fragShader;
1092   bool        applied = DevelTexture::ApplyNativeFragmentShader(nativeTexture, fragShader);
1093
1094   DALI_TEST_CHECK(!applied);
1095   DALI_TEST_CHECK(fragShader.empty());
1096   END_TEST;
1097 }
1098
1099 int UtcDaliTextureApplyFragShaderN2(void)
1100 {
1101   TestApplication application;
1102   unsigned int    width(64);
1103   unsigned int    height(64);
1104   Texture         texture = CreateTexture(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
1105
1106   const std::string baseFragShader =
1107     "varying mediump vec4 uColor;\n"
1108     "void main(){\n"
1109     "  gl_FragColor=uColor;\n"
1110     "}\n";
1111   std::string fragShader = baseFragShader;
1112   bool        applied    = DevelTexture::ApplyNativeFragmentShader(texture, fragShader);
1113
1114   DALI_TEST_CHECK(!applied);
1115   DALI_TEST_CHECK(!baseFragShader.compare(fragShader));
1116   END_TEST;
1117 }