dali/internal/render/renderers/render-texture.cpp

   1 /*
   2  * Copyright (c) 2017 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 // CLASS HEADER
  18 #include <dali/internal/render/renderers/render-texture.h>
  19 #include <dali/devel-api/images/native-image-interface-extension.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <math.h>   //floor, log2
  23
  24 namespace Dali
  25 {
  26 namespace Internal
  27 {
  28 namespace Render
  29 {
  30
  31 namespace
  32 {
  33
  34 // These match the GL specification
  35 const GLint GL_MINIFY_DEFAULT  = GL_NEAREST_MIPMAP_LINEAR;
  36 const GLint GL_MAGNIFY_DEFAULT = GL_LINEAR;
  37 const GLint GL_WRAP_DEFAULT  = GL_CLAMP_TO_EDGE;
  38
  39 // These are the Dali defaults
  40 const GLint DALI_MINIFY_DEFAULT  = GL_LINEAR;
  41 const GLint DALI_MAGNIFY_DEFAULT = GL_LINEAR;
  42
  43 /**
  44  * @brief Convert a FilterMode to its corresponding GL type.
  45  *
  46  * @param[in] filterMode The FilterMode type.
  47  * @param[in] daliDefault The filter mode to use if filterMode is DEFAULT.
  48  * @param[in] glDefault The filter mode to use if filterMode is NONE.
  49  * @return the equivalent GL filter mode.
  50  */
  51 GLint FilterModeToGL( FilterMode::Type filterMode, GLint daliDefault, GLint glDefault )
  52 {
  53   switch( filterMode )
  54   {
  55     case FilterMode::NEAREST:
  56     {
  57       return GL_NEAREST;
  58     }
  59     case FilterMode::LINEAR:
  60     {
  61       return GL_LINEAR;
  62     }
  63     case FilterMode::NONE:
  64     {
  65       return glDefault;
  66     }
  67     case FilterMode::NEAREST_MIPMAP_NEAREST:
  68     {
  69       return GL_NEAREST_MIPMAP_NEAREST;
  70     }
  71     case FilterMode::LINEAR_MIPMAP_NEAREST:
  72     {
  73       return GL_LINEAR_MIPMAP_NEAREST;
  74     }
  75     case FilterMode::NEAREST_MIPMAP_LINEAR:
  76     {
  77       return GL_NEAREST_MIPMAP_LINEAR;
  78     }
  79     case FilterMode::LINEAR_MIPMAP_LINEAR:
  80     {
  81       return GL_LINEAR_MIPMAP_LINEAR;
  82     }
  83     case FilterMode::DEFAULT:
  84     {
  85       return daliDefault;
  86     }
  87   }
  88
  89   return daliDefault;
  90 }
  91
  92 /**
  93  * @brief Convert from a WrapMode to its corresponding GL enumeration
  94  * @param[in] wrapMode The wrap mode
  95  * @param[in] defaultWrapMode The mode to use if WrapMode is Default
  96  * @return The equivalent GL wrap mode
  97  */
  98 GLint WrapModeToGL( WrapMode::Type wrapMode, GLint defaultWrapMode )
  99 {
 100   switch( wrapMode )
 101   {
 102     case WrapMode::CLAMP_TO_EDGE:
 103     {
 104       return GL_CLAMP_TO_EDGE;
 105     }
 106     case WrapMode::REPEAT:
 107     {
 108       return GL_REPEAT;
 109     }
 110     case WrapMode::MIRRORED_REPEAT:
 111     {
 112       return GL_MIRRORED_REPEAT;
 113     }
 114     case WrapMode::DEFAULT:
 115     {
 116       return defaultWrapMode;
 117     }
 118   }
 119
 120   return defaultWrapMode;
 121 }
 122
 123 /**
 124  * @brief Retrive GL internal format and pixel data type from a Pixel::Format
 125  * @param[in] pixelFormat The pixel format
 126  * @param[out] pixelDataType The data type of the pixel data
 127  * @param[out] internalFormat The internal format
 128  */
 129 void PixelFormatToGl( Pixel::Format pixelformat, unsigned& pixelDataType, unsigned& internalFormat )
 130 {
 131   // Compressed textures have no pixelDataType, so init to an invalid value:
 132   pixelDataType  = -1;
 133
 134   switch( pixelformat )
 135   {
 136     case Pixel::A8:
 137     {
 138       pixelDataType = GL_UNSIGNED_BYTE;
 139       internalFormat= GL_ALPHA;
 140       break;
 141     }
 142
 143     case Pixel::L8:
 144     {
 145       pixelDataType = GL_UNSIGNED_BYTE;
 146       internalFormat= GL_LUMINANCE;
 147       break;
 148     }
 149
 150     case Pixel::LA88:
 151     {
 152       pixelDataType = GL_UNSIGNED_BYTE;
 153       internalFormat= GL_LUMINANCE_ALPHA;
 154       break;
 155     }
 156
 157     case Pixel::RGB565:
 158     {
 159       pixelDataType = GL_UNSIGNED_SHORT_5_6_5;
 160       internalFormat= GL_RGB;
 161       break;
 162     }
 163
 164     case Pixel::BGR565:
 165     {
 166       DALI_LOG_ERROR("Pixel format BGR565 is not supported by GLES.\n");
 167       pixelDataType  = GL_UNSIGNED_SHORT_5_6_5;
 168 #ifdef _ARCH_ARM_
 169       internalFormat= GL_BGRA_EXT; // alpha is reserved but not used
 170 #else
 171       internalFormat= GL_RGBA;     // alpha is reserved but not used
 172 #endif
 173       break;
 174     }
 175
 176     case Pixel::RGBA4444:
 177     {
 178       pixelDataType = GL_UNSIGNED_SHORT_4_4_4_4;
 179       internalFormat= GL_RGBA;
 180       break;
 181     }
 182
 183     case Pixel::BGRA4444:
 184     {
 185       DALI_LOG_ERROR("Pixel format BGRA4444 is not supported by GLES.\n");
 186       pixelDataType  = GL_UNSIGNED_SHORT_4_4_4_4;
 187 #ifdef _ARCH_ARM_
 188       internalFormat= GL_BGRA_EXT; // alpha is reserved but not used
 189 #else
 190       internalFormat= GL_RGBA;     // alpha is reserved but not used
 191 #endif
 192       break;
 193     }
 194
 195     case Pixel::RGBA5551:
 196     {
 197       pixelDataType = GL_UNSIGNED_SHORT_5_5_5_1;
 198       internalFormat= GL_RGBA;
 199       break;
 200     }
 201
 202     case Pixel::BGRA5551:
 203     {
 204       DALI_LOG_ERROR("Pixel format BGRA5551 is not supported by GLES.\n");
 205       pixelDataType  = GL_UNSIGNED_SHORT_5_5_5_1;
 206 #ifdef _ARCH_ARM_
 207       internalFormat= GL_BGRA_EXT; // alpha is reserved but not used
 208 #else
 209       internalFormat= GL_RGBA;     // alpha is reserved but not used
 210 #endif
 211       break;
 212     }
 213
 214     case Pixel::RGB888:
 215     {
 216       pixelDataType = GL_UNSIGNED_BYTE;
 217       internalFormat= GL_RGB;
 218       break;
 219     }
 220
 221     case Pixel::RGB8888:
 222     {
 223       pixelDataType = GL_UNSIGNED_BYTE;
 224       internalFormat= GL_RGBA;     // alpha is reserved but not used
 225       break;
 226     }
 227
 228     case Pixel::BGR8888:
 229     {
 230       pixelDataType = GL_UNSIGNED_BYTE;
 231 #ifdef GL_BGRA_EXT
 232       internalFormat= GL_BGRA_EXT; // alpha is reserved but not used
 233 #else
 234       internalFormat= GL_RGBA;     // alpha is reserved but not used
 235 #endif
 236     break;
 237     }
 238
 239     case Pixel::RGBA8888:
 240     {
 241       pixelDataType = GL_UNSIGNED_BYTE;
 242       internalFormat= GL_RGBA;
 243       break;
 244     }
 245
 246     case Pixel::BGRA8888:
 247     {
 248       pixelDataType = GL_UNSIGNED_BYTE;
 249 #ifdef GL_BGRA_EXT
 250       internalFormat= GL_BGRA_EXT; // alpha is reserved but not used
 251 #else
 252       internalFormat= GL_RGBA;     // alpha is reserved but not used
 253 #endif
 254       break;
 255     }
 256
 257     // GLES 2 extension compressed formats:
 258     case Pixel::COMPRESSED_RGB8_ETC1:
 259     {
 260       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using non-standard GLES 2.0 extension compressed pixel format COMPRESSED_RGB8_ETC1.\n" );
 261       internalFormat = 0x8D64; ///! < Hardcoded so we can test before we move to GLES 3.0 or greater.
 262       break;
 263     }
 264     case Pixel::COMPRESSED_RGB_PVRTC_4BPPV1:
 265     {
 266       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using non-standard GLES 2.0 extension compressed pixel format COMPRESSED_RGB_PVRTC_4BPPV1.\n" );
 267       internalFormat = 0x8C00; ///! < Hardcoded so we can test before we move to GLES 3.0 or greater.
 268       break;
 269     }
 270
 271     // GLES 3.0 standard compressed formats:
 272     case Pixel::COMPRESSED_R11_EAC:
 273     {
 274       DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.0 standard compressed pixel format COMPRESSED_R11_EAC.\n");
 275       internalFormat = GL_COMPRESSED_R11_EAC;
 276       break;
 277     }
 278     case Pixel::COMPRESSED_SIGNED_R11_EAC:
 279     {
 280       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.0 standard compressed pixel format COMPRESSED_SIGNED_R11_EAC.\n" );
 281       internalFormat = GL_COMPRESSED_SIGNED_R11_EAC;
 282       break;
 283     }
 284     case Pixel::COMPRESSED_RG11_EAC:
 285     {
 286       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.0 standard compressed pixel format COMPRESSED_RG11_EAC.\n" );
 287       internalFormat = GL_COMPRESSED_RG11_EAC;
 288       break;
 289     }
 290     case Pixel::COMPRESSED_SIGNED_RG11_EAC:
 291     {
 292       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.0 standard compressed pixel format COMPRESSED_SIGNED_RG11_EAC.\n" );
 293       internalFormat = GL_COMPRESSED_SIGNED_RG11_EAC;
 294       break;
 295     }
 296     case Pixel::COMPRESSED_RGB8_ETC2:
 297     {
 298       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.0 standard compressed pixel format COMPRESSED_RGB8_ETC2.\n" );
 299       internalFormat = GL_COMPRESSED_RGB8_ETC2;
 300       break;
 301     }
 302     case Pixel::COMPRESSED_SRGB8_ETC2:
 303     {
 304       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.0 standard compressed pixel format COMPRESSED_SRGB8_ETC2.\n" );
 305       internalFormat = GL_COMPRESSED_SRGB8_ETC2;
 306       break;
 307     }
 308     case Pixel::COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
 309     {
 310       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.0 standard compressed pixel format COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2.\n" );
 311       internalFormat = GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2;
 312       break;
 313     }
 314     case Pixel::COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
 315     {
 316       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.0 standard compressed pixel format COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2.\n" );
 317       internalFormat = GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2;
 318       break;
 319     }
 320     case Pixel::COMPRESSED_RGBA8_ETC2_EAC:
 321     {
 322       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.0 standard compressed pixel format COMPRESSED_RGBA8_ETC2_EAC.\n" );
 323       internalFormat = GL_COMPRESSED_RGBA8_ETC2_EAC;
 324       break;
 325     }
 326     case Pixel::COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
 327     {
 328       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.0 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ETC2_EAC.\n" );
 329       internalFormat = GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC;
 330       break;
 331     }
 332
 333     // GLES 3.1 extension compressed formats:
 334     case Pixel::COMPRESSED_RGBA_ASTC_4x4_KHR:
 335     {
 336       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_4x4_KHR.\n" );
 337       internalFormat = GL_COMPRESSED_RGBA_ASTC_4x4_KHR;
 338       break;
 339     }
 340     case Pixel::COMPRESSED_RGBA_ASTC_5x4_KHR:
 341     {
 342       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_5x4_KHR.\n" );
 343       internalFormat = GL_COMPRESSED_RGBA_ASTC_5x4_KHR;
 344       break;
 345     }
 346     case Pixel::COMPRESSED_RGBA_ASTC_5x5_KHR:
 347     {
 348       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_5x5_KHR.\n" );
 349       internalFormat = GL_COMPRESSED_RGBA_ASTC_5x5_KHR;
 350       break;
 351     }
 352     case Pixel::COMPRESSED_RGBA_ASTC_6x5_KHR:
 353     {
 354       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_6x5_KHR.\n" );
 355       internalFormat = GL_COMPRESSED_RGBA_ASTC_6x5_KHR;
 356       break;
 357     }
 358     case Pixel::COMPRESSED_RGBA_ASTC_6x6_KHR:
 359     {
 360       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_6x6_KHR.\n" );
 361       internalFormat = GL_COMPRESSED_RGBA_ASTC_6x6_KHR;
 362       break;
 363     }
 364     case Pixel::COMPRESSED_RGBA_ASTC_8x5_KHR:
 365     {
 366       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_8x5_KHR.\n" );
 367       internalFormat = GL_COMPRESSED_RGBA_ASTC_8x5_KHR;
 368       break;
 369     }
 370     case Pixel::COMPRESSED_RGBA_ASTC_8x6_KHR:
 371     {
 372       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_8x6_KHR.\n" );
 373       internalFormat = GL_COMPRESSED_RGBA_ASTC_8x6_KHR;
 374       break;
 375     }
 376     case Pixel::COMPRESSED_RGBA_ASTC_8x8_KHR:
 377     {
 378       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_8x8_KHR.\n" );
 379       internalFormat = GL_COMPRESSED_RGBA_ASTC_8x8_KHR;
 380       break;
 381     }
 382     case Pixel::COMPRESSED_RGBA_ASTC_10x5_KHR:
 383     {
 384       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_10x5_KHR.\n" );
 385       internalFormat = GL_COMPRESSED_RGBA_ASTC_10x5_KHR;
 386       break;
 387     }
 388     case Pixel::COMPRESSED_RGBA_ASTC_10x6_KHR:
 389     {
 390       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_10x6_KHR.\n" );
 391       internalFormat = GL_COMPRESSED_RGBA_ASTC_10x6_KHR;
 392       break;
 393     }
 394     case Pixel::COMPRESSED_RGBA_ASTC_10x8_KHR:
 395     {
 396       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_10x8_KHR.\n" );
 397       internalFormat = GL_COMPRESSED_RGBA_ASTC_10x8_KHR;
 398       break;
 399     }
 400     case Pixel::COMPRESSED_RGBA_ASTC_10x10_KHR:
 401     {
 402       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_10x10_KHR.\n" );
 403       internalFormat = GL_COMPRESSED_RGBA_ASTC_10x10_KHR;
 404       break;
 405     }
 406     case Pixel::COMPRESSED_RGBA_ASTC_12x10_KHR:
 407     {
 408       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_12x10_KHR.\n" );
 409       internalFormat = GL_COMPRESSED_RGBA_ASTC_12x10_KHR;
 410       break;
 411     }
 412     case Pixel::COMPRESSED_RGBA_ASTC_12x12_KHR:
 413     {
 414       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_12x12_KHR.\n" );
 415       internalFormat = GL_COMPRESSED_RGBA_ASTC_12x12_KHR;
 416       break;
 417     }
 418     case Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:
 419     {
 420       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR.\n" );
 421       internalFormat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR;
 422       break;
 423     }
 424     case Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:
 425     {
 426       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR.\n" );
 427       internalFormat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR;
 428       break;
 429     }
 430     case Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:
 431     {
 432       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR.\n" );
 433       internalFormat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR;
 434       break;
 435     }
 436     case Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:
 437     {
 438       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR.\n" );
 439       internalFormat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR;
 440       break;
 441     }
 442     case Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:
 443     {
 444       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR.\n" );
 445       internalFormat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR;
 446       break;
 447     }
 448     case Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR:
 449     {
 450       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR.\n" );
 451       internalFormat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR;
 452       break;
 453     }
 454     case Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:
 455     {
 456       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR.\n" );
 457       internalFormat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR;
 458       break;
 459     }
 460     case Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:
 461     {
 462       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR.\n" );
 463       internalFormat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR;
 464       break;
 465     }
 466     case Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:
 467     {
 468       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR.\n" );
 469       internalFormat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR;
 470       break;
 471     }
 472     case Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:
 473     {
 474       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR.\n" );
 475       internalFormat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR;
 476       break;
 477     }
 478     case Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:
 479     {
 480       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR.\n" );
 481       internalFormat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR;
 482       break;
 483     }
 484     case Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:
 485     {
 486       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR.\n" );
 487       internalFormat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR;
 488       break;
 489     }
 490     case Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:
 491     {
 492       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR.\n" );
 493       internalFormat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR;
 494       break;
 495     }
 496     case Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:
 497     {
 498       DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR.\n" );
 499       internalFormat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR;
 500       break;
 501     }
 502
 503     case Pixel::INVALID:
 504     {
 505       DALI_LOG_ERROR( "Invalid pixel format for bitmap\n" );
 506       internalFormat = 0;
 507       break;
 508     }
 509   }
 510 }
 511
 512 /**
 513  * @brief Whether specified pixel format is compressed.
 514  *
 515  * @param [in] pixelformat Pixel format
 516  * @return true if format is compressed, false otherwise
 517  */
 518 bool IsCompressedFormat(Pixel::Format pixelFormat)
 519 {
 520   switch (pixelFormat)
 521   {
 522     case Pixel::L8:
 523     case Pixel::A8:
 524     case Pixel::LA88:
 525     case Pixel::RGB565:
 526     case Pixel::RGBA4444:
 527     case Pixel::RGBA5551:
 528     case Pixel::BGR565:
 529     case Pixel::BGRA4444:
 530     case Pixel::BGRA5551:
 531     case Pixel::RGB888:
 532     case Pixel::RGB8888:
 533     case Pixel::BGR8888:
 534     case Pixel::RGBA8888:
 535     case Pixel::BGRA8888:
 536     case Pixel::INVALID:
 537     {
 538       return false;
 539     }
 540
 541     case Pixel::COMPRESSED_R11_EAC:
 542     case Pixel::COMPRESSED_SIGNED_R11_EAC:
 543     case Pixel::COMPRESSED_RG11_EAC:
 544     case Pixel::COMPRESSED_SIGNED_RG11_EAC:
 545     case Pixel::COMPRESSED_RGB8_ETC2:
 546     case Pixel::COMPRESSED_SRGB8_ETC2:
 547     case Pixel::COMPRESSED_RGB8_ETC1:
 548     case Pixel::COMPRESSED_RGB_PVRTC_4BPPV1:
 549     case Pixel::COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
 550     case Pixel::COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
 551     case Pixel::COMPRESSED_RGBA8_ETC2_EAC:
 552     case Pixel::COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
 553     case Pixel::COMPRESSED_RGBA_ASTC_4x4_KHR:
 554     case Pixel::COMPRESSED_RGBA_ASTC_5x4_KHR:
 555     case Pixel::COMPRESSED_RGBA_ASTC_5x5_KHR:
 556     case Pixel::COMPRESSED_RGBA_ASTC_6x5_KHR:
 557     case Pixel::COMPRESSED_RGBA_ASTC_6x6_KHR:
 558     case Pixel::COMPRESSED_RGBA_ASTC_8x5_KHR:
 559     case Pixel::COMPRESSED_RGBA_ASTC_8x6_KHR:
 560     case Pixel::COMPRESSED_RGBA_ASTC_8x8_KHR:
 561     case Pixel::COMPRESSED_RGBA_ASTC_10x5_KHR:
 562     case Pixel::COMPRESSED_RGBA_ASTC_10x6_KHR:
 563     case Pixel::COMPRESSED_RGBA_ASTC_10x8_KHR:
 564     case Pixel::COMPRESSED_RGBA_ASTC_10x10_KHR:
 565     case Pixel::COMPRESSED_RGBA_ASTC_12x10_KHR:
 566     case Pixel::COMPRESSED_RGBA_ASTC_12x12_KHR:
 567     case Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:
 568     case Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:
 569     case Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:
 570     case Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:
 571     case Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:
 572     case Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR:
 573     case Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:
 574     case Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:
 575     case Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:
 576     case Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:
 577     case Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:
 578     case Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:
 579     case Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:
 580     case Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:
 581     {
 582       return true;
 583     }
 584   }
 585
 586   return false;
 587 }
 588
 589 } //Unnamed namespace
 590
 591
 592 Texture::Texture( Type type, Pixel::Format format, unsigned int width, unsigned int height )
 593 :mId( 0 ),
 594  mTarget( (type == TextureType::TEXTURE_2D)? GL_TEXTURE_2D : GL_TEXTURE_CUBE_MAP ),
 595  mType( type ),
 596  mSampler(),
 597  mNativeImage(),
 598  mInternalFormat(GL_RGB),
 599  mPixelDataType(GL_UNSIGNED_BYTE),
 600  mWidth( width ),
 601  mHeight( height ),
 602  mMaxMipMapLevel(0),
 603  mHasAlpha( HasAlpha( format ) ),
 604  mIsCompressed( IsCompressedFormat( format ) )
 605 {
 606   PixelFormatToGl( format, mPixelDataType, mInternalFormat );
 607 }
 608
 609 Texture::Texture( NativeImageInterfacePtr nativeImageInterface )
 610 :mId( 0 ),
 611  mTarget( GL_TEXTURE_2D ),
 612  mType( TextureType::TEXTURE_2D ),
 613  mSampler(),
 614  mNativeImage( nativeImageInterface ),
 615  mInternalFormat(GL_RGB),
 616  mPixelDataType(GL_UNSIGNED_BYTE),
 617  mWidth( nativeImageInterface->GetWidth() ),
 618  mHeight( nativeImageInterface->GetHeight() ),
 619  mMaxMipMapLevel(0),
 620  mHasAlpha( nativeImageInterface->RequiresBlending() ),
 621  mIsCompressed( false )
 622 {
 623 }
 624
 625 Texture::~Texture()
 626 {}
 627
 628 void Texture::Destroy( Context& context )
 629 {
 630   if( mId )
 631   {
 632     context.DeleteTextures( 1, &mId );
 633
 634     if( mNativeImage )
 635     {
 636       mNativeImage->GlExtensionDestroy();
 637     }
 638   }
 639 }
 640
 641 void Texture::GlContextDestroyed()
 642 {
 643   mId = 0u;
 644 }
 645
 646 void Texture::Initialize(Context& context)
 647 {
 648   if( mNativeImage )
 649   {
 650     if( mNativeImage->GlExtensionCreate() )
 651     {
 652       NativeImageInterface::Extension* extension = mNativeImage->GetExtension();
 653       if( extension )
 654       {
 655         mTarget = extension->GetEglImageTextureTarget();
 656       }
 657
 658       context.GenTextures( 1, &mId );
 659       context.BindTexture( mTarget, mId );
 660       context.PixelStorei( GL_UNPACK_ALIGNMENT, 1 ); // We always use tightly packed data
 661
 662       //Apply default sampling parameters
 663       context.TexParameteri( mTarget, GL_TEXTURE_MIN_FILTER, DALI_MINIFY_DEFAULT );
 664       context.TexParameteri( mTarget, GL_TEXTURE_MAG_FILTER, DALI_MAGNIFY_DEFAULT );
 665       context.TexParameteri( mTarget, GL_TEXTURE_WRAP_S, GL_WRAP_DEFAULT );
 666       context.TexParameteri( mTarget, GL_TEXTURE_WRAP_T, GL_WRAP_DEFAULT );
 667
 668       // platform specific implementation decides on what GL extension to use
 669       if( mNativeImage->TargetTexture() != 0u )
 670       {
 671         context.DeleteTextures( 1, &mId );
 672         mNativeImage->GlExtensionDestroy();
 673         mId = 0u;
 674       }
 675     }
 676   }
 677   else
 678   {
 679     //Create the texture and reserve memory for the first mipmap level.
 680     context.GenTextures( 1, &mId );
 681     context.BindTexture( mTarget, mId );
 682     context.PixelStorei( GL_UNPACK_ALIGNMENT, 1 ); // We always use tightly packed data
 683
 684     //Apply default sampling parameters
 685     context.TexParameteri( mTarget, GL_TEXTURE_MIN_FILTER, DALI_MINIFY_DEFAULT );
 686     context.TexParameteri( mTarget, GL_TEXTURE_MAG_FILTER, DALI_MAGNIFY_DEFAULT );
 687     context.TexParameteri( mTarget, GL_TEXTURE_WRAP_S, GL_WRAP_DEFAULT );
 688     context.TexParameteri( mTarget, GL_TEXTURE_WRAP_T, GL_WRAP_DEFAULT );
 689
 690     if( mType == TextureType::TEXTURE_2D )
 691     {
 692       if( !mIsCompressed )
 693       {
 694         context.TexImage2D(GL_TEXTURE_2D, 0, mInternalFormat, mWidth, mHeight, 0, mInternalFormat, mPixelDataType, 0 );
 695       }
 696       else
 697       {
 698         context.CompressedTexImage2D(GL_TEXTURE_2D, 0, mInternalFormat, mWidth, mHeight, 0, 0, 0 );
 699       }
 700     }
 701     else if( mType == TextureType::TEXTURE_CUBE )
 702     {
 703       if( !mIsCompressed )
 704       {
 705         for( unsigned int i(0); i<6; ++i )
 706         {
 707           context.TexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, mInternalFormat, mWidth, mHeight, 0, mInternalFormat, mPixelDataType, 0 );
 708         }
 709       }
 710       else
 711       {
 712         for( unsigned int i(0); i<6; ++i )
 713         {
 714           context.CompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, mInternalFormat, mWidth, mHeight, 0, 0, 0 );
 715         }
 716       }
 717       context.TexParameteri( mTarget, GL_TEXTURE_WRAP_R, GL_WRAP_DEFAULT );
 718     }
 719   }
 720 }
 721
 722 void Texture::Upload( Context& context, PixelDataPtr pixelData, const Internal::Texture::UploadParams& params  )
 723 {
 724   DALI_ASSERT_ALWAYS( mNativeImage == NULL );
 725
 726   //Get pointer to the data of the PixelData object
 727   unsigned char* buffer( pixelData->GetBuffer() );
 728
 729   //This buffer is only used if manually converting from RGB to RGBA
 730   unsigned char* tempBuffer(0);
 731
 732   //Get pixel format and data type of the data contained in the PixelData object
 733   GLenum pixelDataFormat, pixelDataElementType;
 734   PixelFormatToGl( pixelData->GetPixelFormat(), pixelDataElementType, pixelDataFormat );
 735
 736   //Get the maximum mipmap level to set GL_TEXTURE_MAX_LEVEL parameter in GLES3x because is not
 737   //necessary to upload all the mipmap levels
 738   mMaxMipMapLevel = ( mMaxMipMapLevel > params.mipmap ) ? mMaxMipMapLevel : params.mipmap;
 739
 740 #if DALI_GLES_VERSION < 30
 741   if( pixelDataFormat == GL_RGB && mInternalFormat == GL_RGBA )
 742   {
 743     //Convert manually from RGB to RGBA if GLES < 3 ( GLES 3 can do the conversion automatically when uploading )
 744     size_t dataSize = static_cast< size_t >( params.width ) * params.height;
 745     tempBuffer = new unsigned char[dataSize*4u];
 746     for( size_t i(0u); i<dataSize; i++ )
 747     {
 748       tempBuffer[i*4u]   = buffer[i*3u];
 749       tempBuffer[i*4u+1] = buffer[i*3u+1];
 750       tempBuffer[i*4u+2] = buffer[i*3u+2];
 751       tempBuffer[i*4u+3] = 0xFF;
 752     }
 753
 754     buffer = tempBuffer;
 755     pixelDataFormat = mInternalFormat;
 756   }
 757 #endif
 758
 759   //Upload data to the texture
 760
 761   context.BindTexture( mTarget, mId );
 762   GLenum target( mTarget );
 763   if( mType == TextureType::TEXTURE_CUBE )
 764   {
 765     target = GL_TEXTURE_CUBE_MAP_POSITIVE_X + params.layer;
 766   }
 767
 768   context.PixelStorei( GL_UNPACK_ALIGNMENT, 1 );
 769
 770   if( params.xOffset == 0 && params.yOffset == 0 &&
 771       params.width  == ( mWidth  / (1<<params.mipmap) ) &&
 772       params.height == ( mHeight / (1<<params.mipmap) ) )
 773   {
 774     //Specifying the whole image for the mipmap. We cannot assume that storage for that mipmap has been created so we need to use TexImage2D
 775     if( !mIsCompressed )
 776     {
 777       context.TexImage2D( target, params.mipmap, mInternalFormat, params.width, params.height, 0, pixelDataFormat, pixelDataElementType, buffer );
 778     }
 779     else
 780     {
 781       context.CompressedTexImage2D( target, params.mipmap, mInternalFormat, params.width, params.height, 0, pixelData->GetBufferSize(), buffer );
 782     }
 783   }
 784   else
 785   {
 786     //Specifying part of the image for the mipmap
 787     if( !mIsCompressed )
 788     {
 789       context.TexSubImage2D( target, params.mipmap,
 790                              params.xOffset, params.yOffset, params.width, params.height,
 791                              pixelDataFormat, pixelDataElementType, buffer );
 792     }
 793     else
 794     {
 795       context.CompressedTexSubImage2D( target, params.mipmap,
 796                                        params.xOffset, params.yOffset, params.width, params.height,
 797                                        pixelDataFormat, pixelData->GetBufferSize(), buffer );
 798     }
 799   }
 800
 801
 802   //Destroy temp buffer used for conversion RGB->RGBA
 803   delete[] tempBuffer;
 804 }
 805
 806 bool Texture::Bind( Context& context, unsigned int textureUnit, Render::Sampler* sampler )
 807 {
 808   if( mNativeImage && mId == 0 )
 809   {
 810     Initialize( context );
 811   }
 812
 813   if( mId != 0 )
 814   {
 815     context.ActiveTexture( static_cast<TextureUnit>(textureUnit) );
 816     context.BindTexture( mTarget, mId );
 817     ApplySampler( context, sampler );
 818
 819     if( mNativeImage )
 820     {
 821       mNativeImage->PrepareTexture();
 822     }
 823
 824     return true;
 825   }
 826
 827   return false;
 828 }
 829
 830 void Texture::ApplySampler( Context& context, Render::Sampler* sampler )
 831 {
 832   Render::Sampler oldSampler = mSampler;
 833   mSampler = sampler ? *sampler : Sampler();
 834
 835   if( mSampler != oldSampler )
 836   {
 837     GLint mode = FilterModeToGL( mSampler.mMinificationFilter, DALI_MINIFY_DEFAULT, GL_MINIFY_DEFAULT );
 838     if( mode != FilterModeToGL( oldSampler.mMinificationFilter, DALI_MINIFY_DEFAULT, GL_MINIFY_DEFAULT ) )
 839     {
 840       context.TexParameteri( mTarget, GL_TEXTURE_MIN_FILTER, mode );
 841     }
 842
 843     mode = FilterModeToGL( mSampler.mMagnificationFilter, DALI_MAGNIFY_DEFAULT, GL_MAGNIFY_DEFAULT );
 844     if( mode != FilterModeToGL( oldSampler.mMagnificationFilter, DALI_MAGNIFY_DEFAULT, GL_MAGNIFY_DEFAULT ) )
 845     {
 846       context.TexParameteri( mTarget, GL_TEXTURE_MAG_FILTER, mode );
 847     }
 848
 849     mode = WrapModeToGL( mSampler.mSWrapMode, GL_WRAP_DEFAULT );
 850     if( mode != WrapModeToGL( oldSampler.mSWrapMode, GL_WRAP_DEFAULT ) )
 851     {
 852       context.TexParameteri( mTarget, GL_TEXTURE_WRAP_S, mode );
 853     }
 854
 855     mode = WrapModeToGL( mSampler.mTWrapMode, GL_WRAP_DEFAULT );
 856     if( mode != WrapModeToGL( oldSampler.mTWrapMode, GL_WRAP_DEFAULT ) )
 857     {
 858       context.TexParameteri( mTarget, GL_TEXTURE_WRAP_T, mode );
 859     }
 860
 861     if( mType == TextureType::TEXTURE_CUBE )
 862     {
 863       mode = WrapModeToGL( mSampler.mRWrapMode, GL_WRAP_DEFAULT );
 864       if( mode != WrapModeToGL( oldSampler.mRWrapMode, GL_WRAP_DEFAULT ) )
 865       {
 866         context.TexParameteri( mTarget, GL_TEXTURE_WRAP_R, mode );
 867       }
 868     }
 869
 870 #if DALI_GLES_VERSION >= 30
 871     //In GLES 3.0 we do not need to upload all of the mipmap levels, but GL_TEXTURE_MAX_LEVEL must be set
 872     if(mMaxMipMapLevel)
 873     {
 874       context.TexParameteri( mTarget, GL_TEXTURE_MAX_LEVEL, mMaxMipMapLevel );
 875     }
 876 #endif
 877
 878   }
 879 }
 880
 881 bool Texture::HasAlphaChannel()
 882 {
 883   return mHasAlpha;
 884 }
 885
 886 void Texture::GenerateMipmaps( Context& context )
 887 {
 888   //GL_TEXTURE_MAX_LEVEL does not need to be set when mipmaps are generated by GL
 889   mMaxMipMapLevel = 0;
 890   context.BindTexture( mTarget, mId );
 891   context.GenerateMipmap( mTarget );
 892 }
 893
 894 } //Render
 895
 896 } //Internal
 897
 898 } //Dali