dali/internal/graphics/gles-impl/gles-graphics-types.h

   1 #ifndef DALI_GRAPHICS_GLES_TYPES_H
   2 #define DALI_GRAPHICS_GLES_TYPES_H
   3
   4 // EXTERNAL INCLUDES
   5 #include <dali/graphics-api/graphics-types.h>
   6 #include <dali/integration-api/gl-abstraction.h>
   7 #include <dali/integration-api/gl-defines.h>
   8
   9 namespace Dali::Graphics::GLES
  10 {
  11 class Buffer;
  12 class RenderPass;
  13 class RenderTarget;
  14 class Framebuffer;
  15
  16 // Conversion functions
  17 /**
  18  * Stucture delivers format and type that can be used
  19  * when creating GL texture
  20  */
  21 struct GLTextureFormatType
  22 {
  23   /**
  24    * Constuctor from Graphics::Format
  25    * @param value
  26    */
  27   constexpr GLTextureFormatType(Graphics::Format value)
  28   {
  29     // lookup table
  30     switch(value)
  31     {
  32       case Graphics::Format::UNDEFINED:
  33       {
  34         Assign(0, 0);
  35         break;
  36       }
  37
  38       // Luminance formats
  39       case Graphics::Format::L8:
  40       {
  41         Assign(GL_LUMINANCE, GL_UNSIGNED_BYTE);
  42         break;
  43       }
  44       case Graphics::Format::L8A8:
  45       {
  46         Assign(GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE);
  47         break;
  48       }
  49
  50       // Packed formats (TODO: find supported)
  51       case Graphics::Format::R4G4_UNORM_PACK8:
  52       {
  53         Assign(0, 0);
  54         break;
  55       }
  56       case Graphics::Format::R4G4B4A4_UNORM_PACK16:
  57       {
  58         Assign(GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4);
  59         break;
  60       }
  61       case Graphics::Format::B4G4R4A4_UNORM_PACK16:
  62       {
  63 #ifdef GL_BGRA_EXT
  64         Assign(GL_BGRA_EXT, GL_UNSIGNED_SHORT_4_4_4_4);
  65 #else
  66         Assign(GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4);
  67 #endif
  68         break;
  69       }
  70       case Graphics::Format::R5G6B5_UNORM_PACK16:
  71       {
  72         Assign(GL_RGB, GL_UNSIGNED_SHORT_5_6_5);
  73         break;
  74       }
  75       case Graphics::Format::B5G6R5_UNORM_PACK16:
  76       {
  77 #ifdef GL_BGRA_EXT
  78         Assign(GL_BGRA_EXT, GL_UNSIGNED_SHORT_5_6_5);
  79 #else
  80         Assign(GL_RGBA, GL_UNSIGNED_SHORT_5_6_5);
  81 #endif
  82         break;
  83       }
  84       case Graphics::Format::R5G5B5A1_UNORM_PACK16:
  85       {
  86         Assign(GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1);
  87         break;
  88       }
  89       case Graphics::Format::B5G5R5A1_UNORM_PACK16:
  90       {
  91 #ifdef GL_BGRA_EXT
  92         Assign(GL_BGRA_EXT, GL_UNSIGNED_SHORT_5_5_5_1);
  93 #else
  94         Assign(GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1);
  95 #endif
  96         break;
  97       }
  98       case Graphics::Format::A1R5G5B5_UNORM_PACK16:
  99       {
 100         Assign(0, 0);
 101         break;
 102       }
 103
 104       // Formats
 105       case Graphics::Format::R8_UNORM:
 106       {
 107         Assign(GL_RED, GL_UNSIGNED_BYTE);
 108         break;
 109       }
 110       case Graphics::Format::R8_SNORM:
 111       {
 112         Assign(GL_RED, GL_BYTE);
 113         break;
 114       }
 115       case Graphics::Format::R8_USCALED:
 116       {
 117         Assign(GL_RED, GL_UNSIGNED_BYTE);
 118         break;
 119       }
 120       case Graphics::Format::R8_SSCALED:
 121       {
 122         Assign(GL_RED, GL_BYTE);
 123         break;
 124       }
 125       case Graphics::Format::R8_UINT:
 126       {
 127         Assign(GL_RED, GL_UNSIGNED_BYTE);
 128         break;
 129       }
 130       case Graphics::Format::R8_SINT:
 131       {
 132         Assign(GL_RED, GL_BYTE);
 133         break;
 134       }
 135       case Graphics::Format::R8_SRGB:
 136       {
 137         Assign(GL_RED, GL_BYTE);
 138         break;
 139       }
 140       case Graphics::Format::R8G8_UNORM:
 141       {
 142         Assign(GL_RG, GL_UNSIGNED_BYTE);
 143         break;
 144       }
 145       case Graphics::Format::R8G8_SNORM:
 146       {
 147         Assign(GL_RG, GL_BYTE);
 148         break;
 149       }
 150       case Graphics::Format::R8G8_USCALED:
 151       {
 152         Assign(GL_RG, GL_UNSIGNED_BYTE);
 153         break;
 154       }
 155       case Graphics::Format::R8G8_SSCALED:
 156       {
 157         Assign(GL_RG, GL_BYTE);
 158         break;
 159       }
 160       case Graphics::Format::R8G8_UINT:
 161       {
 162         Assign(GL_RG, GL_UNSIGNED_BYTE);
 163         break;
 164       }
 165       case Graphics::Format::R8G8_SINT:
 166       {
 167         Assign(GL_RG, GL_BYTE);
 168         break;
 169       }
 170       case Graphics::Format::R8G8_SRGB:
 171       {
 172         Assign(GL_RG, GL_BYTE);
 173         break;
 174       }
 175       case Graphics::Format::R8G8B8_UNORM:
 176       {
 177         Assign(GL_RGB, GL_UNSIGNED_BYTE);
 178         break;
 179       }
 180       case Graphics::Format::R8G8B8_SNORM:
 181       {
 182         Assign(GL_RGB, GL_BYTE);
 183         break;
 184       }
 185       case Graphics::Format::R8G8B8_USCALED:
 186       {
 187         Assign(GL_RGB, GL_UNSIGNED_BYTE);
 188         break;
 189       }
 190       case Graphics::Format::R8G8B8_SSCALED:
 191       {
 192         Assign(GL_RGB, GL_BYTE);
 193         break;
 194       }
 195       case Graphics::Format::R8G8B8_UINT:
 196       {
 197         Assign(GL_RGB, GL_UNSIGNED_BYTE);
 198         break;
 199       }
 200       case Graphics::Format::R8G8B8_SINT:
 201       {
 202         Assign(GL_RGB, GL_BYTE);
 203         break;
 204       }
 205       case Graphics::Format::R8G8B8_SRGB:
 206       {
 207         Assign(GL_RGB, GL_BYTE);
 208         break;
 209       }
 210
 211       // BGR not supported in GLES
 212       case Graphics::Format::B8G8R8_UNORM:
 213       case Graphics::Format::B8G8R8_SNORM:
 214       case Graphics::Format::B8G8R8_USCALED:
 215       case Graphics::Format::B8G8R8_SSCALED:
 216       case Graphics::Format::B8G8R8_UINT:
 217       case Graphics::Format::B8G8R8_SINT:
 218       case Graphics::Format::B8G8R8_SRGB:
 219       {
 220         Assign(0, 0);
 221         break;
 222       }
 223
 224       // RGBA
 225       case Graphics::Format::R8G8B8A8_UNORM:
 226       {
 227         Assign(GL_RGBA, GL_UNSIGNED_BYTE);
 228         break;
 229       }
 230       case Graphics::Format::R8G8B8A8_SNORM:
 231       {
 232         Assign(GL_RGBA, GL_BYTE);
 233         break;
 234       }
 235       case Graphics::Format::R8G8B8A8_USCALED:
 236       {
 237         Assign(GL_RGBA, GL_UNSIGNED_BYTE);
 238         break;
 239       }
 240       case Graphics::Format::R8G8B8A8_SSCALED:
 241       {
 242         Assign(GL_RGBA, GL_BYTE);
 243         break;
 244       }
 245       case Graphics::Format::R8G8B8A8_UINT:
 246       {
 247         Assign(GL_RGBA, GL_UNSIGNED_BYTE);
 248         break;
 249       }
 250       case Graphics::Format::R8G8B8A8_SINT:
 251       {
 252         Assign(GL_RGBA, GL_BYTE);
 253         break;
 254       }
 255       case Graphics::Format::R8G8B8A8_SRGB:
 256       {
 257         Assign(GL_RGBA, GL_BYTE);
 258         break;
 259       }
 260
 261       // BGRA when only support GL_BGRA_EXT. otherwise, use RGBA
 262       case Graphics::Format::B8G8R8A8_UNORM:
 263       {
 264 #ifdef GL_BGRA_EXT
 265         Assign(GL_BGRA_EXT, GL_UNSIGNED_BYTE);
 266 #else
 267         Assign(GL_RGBA, GL_UNSIGNED_BYTE);
 268 #endif
 269         break;
 270       }
 271       case Graphics::Format::B8G8R8A8_SNORM:
 272       {
 273 #ifdef GL_BGRA_EXT
 274         Assign(GL_BGRA_EXT, GL_BYTE);
 275 #else
 276         Assign(GL_RGBA, GL_BYTE);
 277 #endif
 278         break;
 279       }
 280       case Graphics::Format::B8G8R8A8_USCALED:
 281       {
 282 #ifdef GL_BGRA_EXT
 283         Assign(GL_BGRA_EXT, GL_UNSIGNED_BYTE);
 284 #else
 285         Assign(GL_RGBA, GL_UNSIGNED_BYTE);
 286 #endif
 287         break;
 288       }
 289       case Graphics::Format::B8G8R8A8_SSCALED:
 290       {
 291 #ifdef GL_BGRA_EXT
 292         Assign(GL_BGRA_EXT, GL_BYTE);
 293 #else
 294         Assign(GL_RGBA, GL_BYTE);
 295 #endif
 296         break;
 297       }
 298       case Graphics::Format::B8G8R8A8_UINT:
 299       {
 300 #ifdef GL_BGRA_EXT
 301         Assign(GL_BGRA_EXT, GL_UNSIGNED_BYTE);
 302 #else
 303         Assign(GL_RGBA, GL_UNSIGNED_BYTE);
 304 #endif
 305         break;
 306       }
 307       case Graphics::Format::B8G8R8A8_SINT:
 308       {
 309 #ifdef GL_BGRA_EXT
 310         Assign(GL_BGRA_EXT, GL_BYTE);
 311 #else
 312         Assign(GL_RGBA, GL_BYTE);
 313 #endif
 314         break;
 315       }
 316       case Graphics::Format::B8G8R8A8_SRGB:
 317       {
 318 #ifdef GL_BGRA_EXT
 319         Assign(GL_BGRA_EXT, GL_BYTE);
 320 #else
 321         Assign(GL_RGBA, GL_BYTE);
 322 #endif
 323         break;
 324       }
 325
 326       // ABGR not supported
 327       case Graphics::Format::A8B8G8R8_UNORM_PACK32:
 328       case Graphics::Format::A8B8G8R8_SNORM_PACK32:
 329       case Graphics::Format::A8B8G8R8_USCALED_PACK32:
 330       case Graphics::Format::A8B8G8R8_SSCALED_PACK32:
 331       case Graphics::Format::A8B8G8R8_UINT_PACK32:
 332       case Graphics::Format::A8B8G8R8_SINT_PACK32:
 333       case Graphics::Format::A8B8G8R8_SRGB_PACK32:
 334       {
 335         Assign(0, 0);
 336         break;
 337       }
 338
 339       // TBD which of the formats are supported
 340       case Graphics::Format::A2R10G10B10_UNORM_PACK32:
 341       case Graphics::Format::A2R10G10B10_SNORM_PACK32:
 342       case Graphics::Format::A2R10G10B10_USCALED_PACK32:
 343       case Graphics::Format::A2R10G10B10_SSCALED_PACK32:
 344       case Graphics::Format::A2R10G10B10_UINT_PACK32:
 345       case Graphics::Format::A2R10G10B10_SINT_PACK32:
 346       case Graphics::Format::A2B10G10R10_UNORM_PACK32:
 347       case Graphics::Format::A2B10G10R10_SNORM_PACK32:
 348       case Graphics::Format::A2B10G10R10_USCALED_PACK32:
 349       case Graphics::Format::A2B10G10R10_SSCALED_PACK32:
 350       case Graphics::Format::A2B10G10R10_UINT_PACK32:
 351       case Graphics::Format::A2B10G10R10_SINT_PACK32:
 352       {
 353         Assign(0, 0);
 354         break;
 355       }
 356       case Graphics::Format::R16_UNORM:
 357       case Graphics::Format::R16_SNORM:
 358       case Graphics::Format::R16_USCALED:
 359       case Graphics::Format::R16_SSCALED:
 360       case Graphics::Format::R16_UINT:
 361       case Graphics::Format::R16_SINT:
 362       case Graphics::Format::R16_SFLOAT:
 363       case Graphics::Format::R16G16_UNORM:
 364       case Graphics::Format::R16G16_SNORM:
 365       case Graphics::Format::R16G16_USCALED:
 366       case Graphics::Format::R16G16_SSCALED:
 367       case Graphics::Format::R16G16_UINT:
 368       case Graphics::Format::R16G16_SINT:
 369       case Graphics::Format::R16G16_SFLOAT:
 370       case Graphics::Format::R16G16B16_UNORM:
 371       case Graphics::Format::R16G16B16_SNORM:
 372       case Graphics::Format::R16G16B16_USCALED:
 373       case Graphics::Format::R16G16B16_SSCALED:
 374       case Graphics::Format::R16G16B16_UINT:
 375       case Graphics::Format::R16G16B16_SINT:
 376       {
 377         Assign(0, 0);
 378         break;
 379       }
 380       case Graphics::Format::R16G16B16_SFLOAT:
 381       {
 382         // GLES 3.0 floating point formats.
 383         AssignInternal(GL_RGB, GL_R11F_G11F_B10F, GL_HALF_FLOAT); // DALi uses compact internal format
 384         break;
 385       }
 386       case Graphics::Format::R16G16B16A16_UNORM:
 387       case Graphics::Format::R16G16B16A16_SNORM:
 388       case Graphics::Format::R16G16B16A16_USCALED:
 389       case Graphics::Format::R16G16B16A16_SSCALED:
 390       case Graphics::Format::R16G16B16A16_UINT:
 391       case Graphics::Format::R16G16B16A16_SINT:
 392       case Graphics::Format::R16G16B16A16_SFLOAT:
 393       case Graphics::Format::R32_UINT:
 394       case Graphics::Format::R32_SINT:
 395       case Graphics::Format::R32_SFLOAT:
 396       case Graphics::Format::R32G32_UINT:
 397       case Graphics::Format::R32G32_SINT:
 398       case Graphics::Format::R32G32_SFLOAT:
 399       case Graphics::Format::R32G32B32_UINT:
 400       case Graphics::Format::R32G32B32_SINT:
 401       {
 402         Assign(0, 0);
 403         break;
 404       }
 405       case Graphics::Format::R32G32B32_SFLOAT:
 406       {
 407         AssignInternal(GL_RGB, GL_R11F_G11F_B10F, GL_FLOAT); // DALi uses compact internal format
 408         break;
 409       }
 410       case Graphics::Format::R32G32B32A32_UINT:
 411       case Graphics::Format::R32G32B32A32_SINT:
 412       case Graphics::Format::R32G32B32A32_SFLOAT:
 413       {
 414         Assign(0, 0);
 415         break;
 416       }
 417       case Graphics::Format::R64_UINT:
 418       case Graphics::Format::R64_SINT:
 419       case Graphics::Format::R64_SFLOAT:
 420       case Graphics::Format::R64G64_UINT:
 421       case Graphics::Format::R64G64_SINT:
 422       case Graphics::Format::R64G64_SFLOAT:
 423       case Graphics::Format::R64G64B64_UINT:
 424       case Graphics::Format::R64G64B64_SINT:
 425       case Graphics::Format::R64G64B64_SFLOAT:
 426       case Graphics::Format::R64G64B64A64_UINT:
 427       case Graphics::Format::R64G64B64A64_SINT:
 428       case Graphics::Format::R64G64B64A64_SFLOAT:
 429       {
 430         Assign(0, 0);
 431         break;
 432       }
 433       case Graphics::Format::R11G11B10_UFLOAT_PACK32:
 434       {
 435         AssignInternal(GL_RGB, GL_R11F_G11F_B10F, GL_FLOAT);
 436         break;
 437       }
 438       case Graphics::Format::B10G11R11_UFLOAT_PACK32:
 439       case Graphics::Format::E5B9G9R9_UFLOAT_PACK32:
 440       {
 441         Assign(0, 0);
 442         break;
 443       }
 444       case Graphics::Format::D16_UNORM:
 445       {
 446         // GLES 3.0 depth and stencil formats
 447         Assign(GL_DEPTH_COMPONENT, GL_UNSIGNED_INT);
 448         break;
 449       }
 450       case Graphics::Format::X8_D24_UNORM_PACK32:
 451       {
 452         Assign(0, 0);
 453         break;
 454       }
 455       case Graphics::Format::D32_SFLOAT:
 456       {
 457         // GLES 3.0 depth and stencil formats
 458         AssignInternal(GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT32F, GL_FLOAT);
 459         break;
 460       }
 461       case Graphics::Format::S8_UINT:
 462       case Graphics::Format::D16_UNORM_S8_UINT:
 463       {
 464         Assign(0, 0);
 465         break;
 466       }
 467       case Graphics::Format::D24_UNORM_S8_UINT:
 468       {
 469         // GLES 3.0 depth and stencil formats
 470         AssignInternal(GL_DEPTH_STENCIL, GL_DEPTH24_STENCIL8, GL_UNSIGNED_INT_24_8);
 471         break;
 472       }
 473       case Graphics::Format::D32_SFLOAT_S8_UINT:
 474       {
 475         Assign(0, 0);
 476         break;
 477       }
 478       case Graphics::Format::BC1_RGB_UNORM_BLOCK:
 479       case Graphics::Format::BC1_RGB_SRGB_BLOCK:
 480       case Graphics::Format::BC1_RGBA_UNORM_BLOCK:
 481       case Graphics::Format::BC1_RGBA_SRGB_BLOCK:
 482       case Graphics::Format::BC2_UNORM_BLOCK:
 483       case Graphics::Format::BC2_SRGB_BLOCK:
 484       case Graphics::Format::BC3_UNORM_BLOCK:
 485       case Graphics::Format::BC3_SRGB_BLOCK:
 486       case Graphics::Format::BC4_UNORM_BLOCK:
 487       case Graphics::Format::BC4_SNORM_BLOCK:
 488       case Graphics::Format::BC5_UNORM_BLOCK:
 489       case Graphics::Format::BC5_SNORM_BLOCK:
 490       case Graphics::Format::BC6H_UFLOAT_BLOCK:
 491       case Graphics::Format::BC6H_SFLOAT_BLOCK:
 492       case Graphics::Format::BC7_UNORM_BLOCK:
 493       case Graphics::Format::BC7_SRGB_BLOCK:
 494       {
 495         Assign(0, 0);
 496         break;
 497       }
 498       case Graphics::Format::ETC2_R8G8B8_UNORM_BLOCK:
 499       {
 500         ///! Using GLES 3.0 standard compressed pixel format COMPRESSED_RGB8_ETC2.
 501         Assign(GL_COMPRESSED_RGB8_ETC2, 0);
 502         break;
 503       }
 504       case Graphics::Format::ETC2_R8G8B8_SRGB_BLOCK:
 505       {
 506         ///! Using GLES 3.0 standard compressed pixel format COMPRESSED_SRGB8_ETC2.
 507         Assign(GL_COMPRESSED_SRGB8_ETC2, 0);
 508         break;
 509       }
 510       case Graphics::Format::ETC2_R8G8B8A1_UNORM_BLOCK:
 511       {
 512         ///! Using GLES 3.0 standard compressed pixel format COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2.
 513         Assign(GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, 0);
 514         break;
 515       }
 516       case Graphics::Format::ETC2_R8G8B8A1_SRGB_BLOCK:
 517       {
 518         ///! Using GLES 3.0 standard compressed pixel format COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2.
 519         Assign(GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, 0);
 520         break;
 521       }
 522       case Graphics::Format::ETC2_R8G8B8A8_UNORM_BLOCK:
 523       {
 524         Assign(GL_COMPRESSED_RGBA8_ETC2_EAC, 0);
 525         break;
 526       }
 527       case Graphics::Format::ETC2_R8G8B8A8_SRGB_BLOCK:
 528       {
 529         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, 0);
 530         break;
 531       }
 532       case Graphics::Format::EAC_R11_UNORM_BLOCK:
 533       {
 534         ///! Using GLES 3.0 standard compressed pixel format COMPRESSED_R11_EAC.
 535         Assign(GL_COMPRESSED_R11_EAC, 0);
 536         break;
 537       }
 538       case Graphics::Format::EAC_R11_SNORM_BLOCK:
 539       {
 540         ///! Using GLES 3.0 standard compressed pixel format COMPRESSED_SIGNED_R11_EAC.
 541         Assign(GL_COMPRESSED_SIGNED_R11_EAC, 0);
 542         break;
 543       }
 544       case Graphics::Format::EAC_R11G11_UNORM_BLOCK:
 545       {
 546         ///! Using GLES 3.0 standard compressed pixel format COMPRESSED_RG11_EAC.
 547         Assign(GL_COMPRESSED_RG11_EAC, 0);
 548         break;
 549       }
 550       case Graphics::Format::EAC_R11G11_SNORM_BLOCK:
 551       {
 552         ///! Using GLES 3.0 standard compressed pixel format COMPRESSED_SIGNED_RG11_EAC.
 553         Assign(GL_COMPRESSED_SIGNED_RG11_EAC, 0);
 554         break;
 555       }
 556       case Graphics::Format::ASTC_4x4_UNORM_BLOCK:
 557       {
 558         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_4x4_KHR.
 559         Assign(GL_COMPRESSED_RGBA_ASTC_4x4_KHR, 0);
 560         break;
 561       }
 562       case Graphics::Format::ASTC_4x4_SRGB_BLOCK:
 563       {
 564         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR.
 565         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR, 0);
 566         break;
 567       }
 568       case Graphics::Format::ASTC_5x4_UNORM_BLOCK:
 569       {
 570         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_5x4_KHR.
 571         Assign(GL_COMPRESSED_RGBA_ASTC_5x4_KHR, 0);
 572         break;
 573       }
 574       case Graphics::Format::ASTC_5x4_SRGB_BLOCK:
 575       {
 576         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR.
 577         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR, 0);
 578         break;
 579       }
 580       case Graphics::Format::ASTC_5x5_UNORM_BLOCK:
 581       {
 582         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_5x5_KHR.
 583         Assign(GL_COMPRESSED_RGBA_ASTC_5x5_KHR, 0);
 584         break;
 585       }
 586       case Graphics::Format::ASTC_5x5_SRGB_BLOCK:
 587       {
 588         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR.
 589         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR, 0);
 590         break;
 591       }
 592       case Graphics::Format::ASTC_6x5_UNORM_BLOCK:
 593       {
 594         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_6x5_KHR.
 595         Assign(GL_COMPRESSED_RGBA_ASTC_6x5_KHR, 0);
 596         break;
 597       }
 598       case Graphics::Format::ASTC_6x5_SRGB_BLOCK:
 599       {
 600         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR.
 601         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR, 0);
 602         break;
 603       }
 604       case Graphics::Format::ASTC_6x6_UNORM_BLOCK:
 605       {
 606         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_6x6_KHR.
 607         Assign(GL_COMPRESSED_RGBA_ASTC_6x6_KHR, 0);
 608         break;
 609       }
 610       case Graphics::Format::ASTC_6x6_SRGB_BLOCK:
 611       {
 612         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR.
 613         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR, 0);
 614         break;
 615       }
 616       case Graphics::Format::ASTC_8x5_UNORM_BLOCK:
 617       {
 618         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_8x5_KHR.
 619         Assign(GL_COMPRESSED_RGBA_ASTC_8x5_KHR, 0);
 620         break;
 621       }
 622       case Graphics::Format::ASTC_8x5_SRGB_BLOCK:
 623       {
 624         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR.
 625         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR, 0);
 626         break;
 627       }
 628       case Graphics::Format::ASTC_8x6_UNORM_BLOCK:
 629       {
 630         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_8x6_KHR.
 631         Assign(GL_COMPRESSED_RGBA_ASTC_8x6_KHR, 0);
 632         break;
 633       }
 634       case Graphics::Format::ASTC_8x6_SRGB_BLOCK:
 635       {
 636         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR.
 637         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR, 0);
 638         break;
 639       }
 640       case Graphics::Format::ASTC_8x8_UNORM_BLOCK:
 641       {
 642         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_8x8_KHR.
 643         Assign(GL_COMPRESSED_RGBA_ASTC_8x8_KHR, 0);
 644         break;
 645       }
 646       case Graphics::Format::ASTC_8x8_SRGB_BLOCK:
 647       {
 648         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR.
 649         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR, 0);
 650         break;
 651       }
 652       case Graphics::Format::ASTC_10x5_UNORM_BLOCK:
 653       {
 654         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_10x5_KHR.
 655         Assign(GL_COMPRESSED_RGBA_ASTC_10x5_KHR, 0);
 656         break;
 657       }
 658       case Graphics::Format::ASTC_10x5_SRGB_BLOCK:
 659       {
 660         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR.
 661         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR, 0);
 662         break;
 663       }
 664       case Graphics::Format::ASTC_10x6_UNORM_BLOCK:
 665       {
 666         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_10x6_KHR.
 667         Assign(GL_COMPRESSED_RGBA_ASTC_10x6_KHR, 0);
 668         break;
 669       }
 670       case Graphics::Format::ASTC_10x6_SRGB_BLOCK:
 671       {
 672         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR.
 673         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR, 0);
 674         break;
 675       }
 676       case Graphics::Format::ASTC_10x8_UNORM_BLOCK:
 677       {
 678         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_10x8_KHR.
 679         Assign(GL_COMPRESSED_RGBA_ASTC_10x8_KHR, 0);
 680         break;
 681       }
 682       case Graphics::Format::ASTC_10x8_SRGB_BLOCK:
 683       {
 684         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR.
 685         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR, 0);
 686         break;
 687       }
 688       case Graphics::Format::ASTC_10x10_UNORM_BLOCK:
 689       {
 690         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_10x10_KHR.
 691         Assign(GL_COMPRESSED_RGBA_ASTC_10x10_KHR, 0);
 692         break;
 693       }
 694       case Graphics::Format::ASTC_10x10_SRGB_BLOCK:
 695       {
 696         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR.
 697         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR, 0);
 698         break;
 699       }
 700       case Graphics::Format::ASTC_12x10_UNORM_BLOCK:
 701       {
 702         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_12x10_KHR.
 703         Assign(GL_COMPRESSED_RGBA_ASTC_12x10_KHR, 0);
 704         break;
 705       }
 706       case Graphics::Format::ASTC_12x10_SRGB_BLOCK:
 707       {
 708         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR.
 709         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR, 0);
 710         break;
 711       }
 712       case Graphics::Format::ASTC_12x12_UNORM_BLOCK:
 713       {
 714         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_12x12_KHR.
 715         Assign(GL_COMPRESSED_RGBA_ASTC_12x12_KHR, 0);
 716         break;
 717       }
 718       case Graphics::Format::ASTC_12x12_SRGB_BLOCK:
 719       {
 720         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR.
 721         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR, 0);
 722         break;
 723       }
 724       case Graphics::Format::PVRTC1_2BPP_UNORM_BLOCK_IMG:
 725       {
 726         Assign(0, 0);
 727         break;
 728       }
 729       case Graphics::Format::PVRTC1_4BPP_UNORM_BLOCK_IMG:
 730       {
 731         ///! Using non-standard GLES 2.0 extension compressed pixel format COMPRESSED_RGB_PVRTC_4BPPV1.
 732         Assign(0x8C00, 0); ///! < Hardcoded so we can test before we move to GLES 3.0 or greater.
 733
 734         break;
 735       }
 736       case Graphics::Format::PVRTC2_2BPP_UNORM_BLOCK_IMG:
 737       case Graphics::Format::PVRTC2_4BPP_UNORM_BLOCK_IMG:
 738       case Graphics::Format::PVRTC1_2BPP_SRGB_BLOCK_IMG:
 739       case Graphics::Format::PVRTC1_4BPP_SRGB_BLOCK_IMG:
 740       case Graphics::Format::PVRTC2_2BPP_SRGB_BLOCK_IMG:
 741       case Graphics::Format::PVRTC2_4BPP_SRGB_BLOCK_IMG:
 742       {
 743         Assign(0, 0);
 744         break;
 745       }
 746     }
 747   }
 748
 749   constexpr inline void Assign(uint32_t f, uint32_t t)
 750   {
 751     format         = f;
 752     internalFormat = f;
 753     type           = t;
 754   }
 755   constexpr inline void AssignInternal(uint32_t f, uint32_t i, uint32_t t)
 756   {
 757     format         = f;
 758     internalFormat = i;
 759     type           = t;
 760   }
 761
 762   uint32_t format{0};
 763   uint32_t internalFormat{0};
 764   uint32_t type{0};
 765 };
 766
 767 struct FormatCompression
 768 {
 769   /**
 770    * Constuctor from Graphics::Format
 771    * @param value
 772    */
 773   constexpr explicit FormatCompression(Graphics::Format value)
 774   {
 775     switch(value)
 776     {
 777       case Graphics::Format::ETC2_R8G8B8_UNORM_BLOCK:
 778       case Graphics::Format::ETC2_R8G8B8_SRGB_BLOCK:
 779       case Graphics::Format::ETC2_R8G8B8A1_UNORM_BLOCK:
 780       case Graphics::Format::ETC2_R8G8B8A1_SRGB_BLOCK:
 781       case Graphics::Format::ETC2_R8G8B8A8_UNORM_BLOCK:
 782       case Graphics::Format::ETC2_R8G8B8A8_SRGB_BLOCK:
 783       case Graphics::Format::EAC_R11_UNORM_BLOCK:
 784       case Graphics::Format::EAC_R11_SNORM_BLOCK:
 785       case Graphics::Format::EAC_R11G11_UNORM_BLOCK:
 786       case Graphics::Format::EAC_R11G11_SNORM_BLOCK:
 787       case Graphics::Format::ASTC_4x4_UNORM_BLOCK:
 788       case Graphics::Format::ASTC_4x4_SRGB_BLOCK:
 789       case Graphics::Format::ASTC_5x4_UNORM_BLOCK:
 790       case Graphics::Format::ASTC_5x4_SRGB_BLOCK:
 791       case Graphics::Format::ASTC_5x5_UNORM_BLOCK:
 792       case Graphics::Format::ASTC_5x5_SRGB_BLOCK:
 793       case Graphics::Format::ASTC_6x5_UNORM_BLOCK:
 794       case Graphics::Format::ASTC_6x5_SRGB_BLOCK:
 795       case Graphics::Format::ASTC_6x6_UNORM_BLOCK:
 796       case Graphics::Format::ASTC_6x6_SRGB_BLOCK:
 797       case Graphics::Format::ASTC_8x5_UNORM_BLOCK:
 798       case Graphics::Format::ASTC_8x5_SRGB_BLOCK:
 799       case Graphics::Format::ASTC_8x6_UNORM_BLOCK:
 800       case Graphics::Format::ASTC_8x6_SRGB_BLOCK:
 801       case Graphics::Format::ASTC_8x8_UNORM_BLOCK:
 802       case Graphics::Format::ASTC_8x8_SRGB_BLOCK:
 803       case Graphics::Format::ASTC_10x5_UNORM_BLOCK:
 804       case Graphics::Format::ASTC_10x5_SRGB_BLOCK:
 805       case Graphics::Format::ASTC_10x6_UNORM_BLOCK:
 806       case Graphics::Format::ASTC_10x6_SRGB_BLOCK:
 807       case Graphics::Format::ASTC_10x8_UNORM_BLOCK:
 808       case Graphics::Format::ASTC_10x8_SRGB_BLOCK:
 809       case Graphics::Format::ASTC_10x10_UNORM_BLOCK:
 810       case Graphics::Format::ASTC_10x10_SRGB_BLOCK:
 811       case Graphics::Format::ASTC_12x10_UNORM_BLOCK:
 812       case Graphics::Format::ASTC_12x10_SRGB_BLOCK:
 813       case Graphics::Format::ASTC_12x12_UNORM_BLOCK:
 814       case Graphics::Format::ASTC_12x12_SRGB_BLOCK:
 815       case Graphics::Format::PVRTC1_2BPP_UNORM_BLOCK_IMG:
 816       case Graphics::Format::PVRTC1_4BPP_UNORM_BLOCK_IMG:
 817       case Graphics::Format::PVRTC2_2BPP_UNORM_BLOCK_IMG:
 818       case Graphics::Format::PVRTC2_4BPP_UNORM_BLOCK_IMG:
 819       case Graphics::Format::PVRTC1_2BPP_SRGB_BLOCK_IMG:
 820       case Graphics::Format::PVRTC1_4BPP_SRGB_BLOCK_IMG:
 821       case Graphics::Format::PVRTC2_2BPP_SRGB_BLOCK_IMG:
 822       case Graphics::Format::PVRTC2_4BPP_SRGB_BLOCK_IMG:
 823         compressed = true;
 824         break;
 825       default:
 826         break;
 827     }
 828   }
 829   bool compressed{false};
 830 };
 831
 832 struct GLSamplerFilter
 833 {
 834   constexpr explicit GLSamplerFilter(Graphics::SamplerFilter filter)
 835   {
 836     switch(filter)
 837     {
 838       case Graphics::SamplerFilter::NEAREST:
 839       {
 840         glFilter = GL_NEAREST;
 841         break;
 842       }
 843       case Graphics::SamplerFilter::LINEAR:
 844       {
 845         glFilter = GL_LINEAR;
 846         break;
 847       }
 848     }
 849   }
 850   uint32_t glFilter{0};
 851 };
 852
 853 struct GLSamplerFilterAndMipMapMode
 854 {
 855   constexpr explicit GLSamplerFilterAndMipMapMode(Graphics::SamplerFilter     filter,
 856                                                   Graphics::SamplerMipmapMode mipMapMode)
 857   {
 858     switch(filter)
 859     {
 860       case Graphics::SamplerFilter::NEAREST:
 861       {
 862         switch(mipMapMode)
 863         {
 864           case Graphics::SamplerMipmapMode::NONE:
 865           {
 866             glFilter = GL_NEAREST;
 867             break;
 868           }
 869           case Graphics::SamplerMipmapMode::NEAREST:
 870           {
 871             glFilter = GL_NEAREST_MIPMAP_NEAREST;
 872             break;
 873           }
 874           case Graphics::SamplerMipmapMode::LINEAR:
 875           {
 876             glFilter = GL_NEAREST_MIPMAP_LINEAR;
 877             break;
 878           }
 879         }
 880         break;
 881       }
 882
 883       case Graphics::SamplerFilter::LINEAR:
 884       {
 885         switch(mipMapMode)
 886         {
 887           case Graphics::SamplerMipmapMode::NONE:
 888           {
 889             glFilter = GL_LINEAR;
 890             break;
 891           }
 892           case Graphics::SamplerMipmapMode::NEAREST:
 893           {
 894             glFilter = GL_LINEAR_MIPMAP_NEAREST;
 895             break;
 896           }
 897           case Graphics::SamplerMipmapMode::LINEAR:
 898           {
 899             glFilter = GL_LINEAR_MIPMAP_LINEAR;
 900             break;
 901           }
 902         }
 903         break;
 904       }
 905     }
 906   }
 907
 908   inline explicit operator uint32_t() const
 909   {
 910     return glFilter;
 911   }
 912
 913   inline operator int() const
 914   {
 915     return static_cast<int>(glFilter);
 916   }
 917
 918   uint32_t glFilter{0};
 919 };
 920
 921 /** Converts vertex format to GL */
 922 struct GLVertexFormat
 923 {
 924   constexpr explicit GLVertexFormat(Graphics::VertexInputFormat gfxFormat)
 925   {
 926     switch(gfxFormat)
 927     {
 928       case VertexInputFormat::FVECTOR2:
 929       {
 930         format = GL_FLOAT;
 931         size   = 2;
 932         break;
 933       }
 934       case VertexInputFormat::FVECTOR3:
 935       {
 936         format = GL_FLOAT;
 937         size   = 3;
 938         break;
 939       }
 940       case VertexInputFormat::FVECTOR4:
 941       {
 942         format = GL_FLOAT;
 943         size   = 4;
 944         break;
 945       }
 946       case VertexInputFormat::FLOAT:
 947       {
 948         format = GL_FLOAT;
 949         size   = 1;
 950         break;
 951       }
 952       case VertexInputFormat::INTEGER:
 953       {
 954         format = GL_INT;
 955         size   = 1;
 956         break;
 957       }
 958       case VertexInputFormat::IVECTOR2:
 959       {
 960         format = GL_INT;
 961         size   = 2;
 962         break;
 963       }
 964       case VertexInputFormat::IVECTOR3:
 965       {
 966         format = GL_INT;
 967         size   = 3;
 968         break;
 969       }
 970       case VertexInputFormat::IVECTOR4:
 971       {
 972         format = GL_INT;
 973         size   = 4;
 974         break;
 975       }
 976       case VertexInputFormat::UNDEFINED:
 977       {
 978         format = 0;
 979         size   = 0;
 980         break;
 981       }
 982     }
 983   }
 984
 985   GLenum   format{0u};
 986   uint32_t size{0u};
 987 };
 988
 989 struct GLTextureTarget
 990 {
 991   constexpr explicit GLTextureTarget(Graphics::TextureType graphicsTextureType)
 992   {
 993     switch(graphicsTextureType)
 994     {
 995       case Graphics::TextureType::TEXTURE_2D:
 996       {
 997         target = GL_TEXTURE_2D;
 998         break;
 999       }
1000       case Graphics::TextureType::TEXTURE_3D:
1001       {
1002         target = GL_TEXTURE_3D;
1003         break;
1004       }
1005       case Graphics::TextureType::TEXTURE_CUBEMAP:
1006       {
1007         target = GL_TEXTURE_CUBE_MAP;
1008         break;
1009       }
1010     }
1011   }
1012   GLenum target{GL_TEXTURE_2D};
1013 };
1014
1015 struct GLAddressMode
1016 {
1017   constexpr explicit GLAddressMode(Graphics::SamplerAddressMode graphicsAddressMode)
1018   {
1019     switch(graphicsAddressMode)
1020     {
1021       case Graphics::SamplerAddressMode::REPEAT:
1022       {
1023         texParameter = GL_REPEAT;
1024         break;
1025       }
1026       case Graphics::SamplerAddressMode::MIRRORED_REPEAT:
1027       {
1028         texParameter = GL_MIRRORED_REPEAT;
1029         break;
1030       }
1031       case Graphics::SamplerAddressMode::CLAMP_TO_EDGE:
1032       {
1033         texParameter = GL_CLAMP_TO_EDGE;
1034         break;
1035       }
1036       case Graphics::SamplerAddressMode::CLAMP_TO_BORDER:
1037       {
1038         texParameter = GL_CLAMP_TO_EDGE;
1039         break;
1040       }
1041       case Graphics::SamplerAddressMode::MIRROR_CLAMP_TO_EDGE:
1042       {
1043         texParameter = GL_CLAMP_TO_EDGE;
1044         break;
1045       }
1046     }
1047   }
1048   GLenum texParameter{GL_CLAMP_TO_EDGE};
1049 };
1050
1051 struct GLCompareOp
1052 {
1053   constexpr explicit GLCompareOp(Graphics::CompareOp compareOp)
1054   {
1055     switch(compareOp)
1056     {
1057       case Graphics::CompareOp::NEVER:
1058         op = GL_NEVER;
1059         break;
1060       case Graphics::CompareOp::LESS:
1061         op = GL_LESS;
1062         break;
1063       case Graphics::CompareOp::EQUAL:
1064         op = GL_EQUAL;
1065         break;
1066       case Graphics::CompareOp::LESS_OR_EQUAL:
1067         op = GL_LEQUAL;
1068         break;
1069       case Graphics::CompareOp::GREATER:
1070         op = GL_GREATER;
1071         break;
1072       case Graphics::CompareOp::NOT_EQUAL:
1073         op = GL_NOTEQUAL;
1074         break;
1075       case Graphics::CompareOp::GREATER_OR_EQUAL:
1076         op = GL_GEQUAL;
1077         break;
1078       case Graphics::CompareOp::ALWAYS:
1079         op = GL_ALWAYS;
1080         break;
1081     }
1082   }
1083   GLenum op{GL_LESS};
1084 };
1085
1086 struct GLStencilOp
1087 {
1088   constexpr explicit GLStencilOp(Graphics::StencilOp stencilOp)
1089   {
1090     switch(stencilOp)
1091     {
1092       case Graphics::StencilOp::KEEP:
1093         op = GL_KEEP;
1094         break;
1095       case Graphics::StencilOp::ZERO:
1096         op = GL_ZERO;
1097         break;
1098       case Graphics::StencilOp::REPLACE:
1099         op = GL_REPLACE;
1100         break;
1101       case Graphics::StencilOp::INCREMENT_AND_CLAMP:
1102         op = GL_INCR;
1103         break;
1104       case Graphics::StencilOp::DECREMENT_AND_CLAMP:
1105         op = GL_DECR;
1106         break;
1107       case Graphics::StencilOp::INVERT:
1108         op = GL_INVERT;
1109         break;
1110       case Graphics::StencilOp::INCREMENT_AND_WRAP:
1111         op = GL_INCR_WRAP;
1112         break;
1113       case Graphics::StencilOp::DECREMENT_AND_WRAP:
1114         op = GL_DECR_WRAP;
1115         break;
1116     }
1117   }
1118   GLenum op{GL_KEEP};
1119 };
1120
1121 /**
1122  * @brief Descriptor of single buffer binding within
1123  * command buffer.
1124  */
1125 struct VertexBufferBindingDescriptor
1126 {
1127   const GLES::Buffer* buffer{nullptr};
1128   uint32_t            offset{0u};
1129 };
1130
1131 /**
1132  * @brief Descriptor of ix buffer binding within
1133  * command buffer.
1134  */
1135 struct IndexBufferBindingDescriptor
1136 {
1137   const GLES::Buffer* buffer{nullptr};
1138   uint32_t            offset{};
1139   Graphics::Format    format{};
1140 };
1141
1142 /**
1143  * @brief Descriptor of uniform buffer binding within
1144  * command buffer.
1145  */
1146 struct UniformBufferBindingDescriptor
1147 {
1148   const GLES::Buffer* buffer{nullptr};
1149   uint32_t            binding{0u};
1150   uint32_t            offset{0u};
1151   bool                emulated; ///<true if UBO is emulated for old gfx API
1152 };
1153
1154 /**
1155  * @brief The descriptor of draw call
1156  */
1157 struct DrawCallDescriptor
1158 {
1159   /**
1160    * @brief Enum specifying type of the draw call
1161    */
1162   enum class Type
1163   {
1164     DRAW,
1165     DRAW_INDEXED,
1166     DRAW_INDEXED_INDIRECT,
1167   };
1168
1169   Type type{}; ///< Type of the draw call
1170
1171   /**
1172    * Union contains data for all types of draw calls.
1173    */
1174   union
1175   {
1176     /**
1177      * @brief Vertex array draw
1178      */
1179     struct
1180     {
1181       uint32_t vertexCount;
1182       uint32_t instanceCount;
1183       uint32_t firstVertex;
1184       uint32_t firstInstance;
1185     } draw;
1186
1187     /**
1188      * @brief Indexed draw
1189      */
1190     struct
1191     {
1192       uint32_t indexCount;
1193       uint32_t instanceCount;
1194       uint32_t firstIndex;
1195       int32_t  vertexOffset;
1196       uint32_t firstInstance;
1197     } drawIndexed;
1198
1199     /**
1200      * @brief Indexed draw indirect
1201      */
1202     struct
1203     {
1204       const GLES::Buffer* buffer;
1205       uint32_t            offset;
1206       uint32_t            drawCount;
1207       uint32_t            stride;
1208     } drawIndexedIndirect;
1209   };
1210 };
1211
1212 /**
1213  * @brief Topologu conversion from Graphics to GLES
1214  */
1215 struct GLESTopology
1216 {
1217   explicit constexpr GLESTopology(PrimitiveTopology topology)
1218   {
1219     switch(topology)
1220     {
1221       case PrimitiveTopology::POINT_LIST:
1222       {
1223         primitiveTopology = GL_POINTS;
1224         break;
1225       }
1226       case PrimitiveTopology::LINE_LIST:
1227       {
1228         primitiveTopology = GL_LINES;
1229         break;
1230       }
1231       case PrimitiveTopology::LINE_LOOP:
1232       {
1233         primitiveTopology = GL_LINE_LOOP;
1234         break;
1235       }
1236       case PrimitiveTopology::LINE_STRIP:
1237       {
1238         primitiveTopology = GL_LINE_STRIP;
1239         break;
1240       }
1241       case PrimitiveTopology::TRIANGLE_LIST:
1242       {
1243         primitiveTopology = GL_TRIANGLES;
1244         break;
1245       }
1246       case PrimitiveTopology::TRIANGLE_STRIP:
1247       {
1248         primitiveTopology = GL_TRIANGLE_STRIP;
1249         break;
1250       }
1251       case PrimitiveTopology::TRIANGLE_FAN:
1252       {
1253         primitiveTopology = GL_TRIANGLE_FAN;
1254         break;
1255       }
1256     }
1257   }
1258
1259   /**
1260    * @brief Explicit type conversion operator
1261    * @return converted value
1262    */
1263   constexpr inline operator GLenum() const
1264   {
1265     return primitiveTopology;
1266   }
1267
1268   GLenum primitiveTopology{0}; ///< Topology
1269 };
1270
1271 /**
1272  * @brief Index format conversion structure
1273  */
1274 struct GLIndexFormat
1275 {
1276   explicit constexpr GLIndexFormat(Format _format)
1277   {
1278     switch(_format)
1279     {
1280       // TODO: add more formats
1281       case Format::R16_UINT:
1282       {
1283         format = GL_UNSIGNED_SHORT;
1284         break;
1285       }
1286       case Format::R32_UINT:
1287       {
1288         format = GL_UNSIGNED_INT;
1289         break;
1290       }
1291       default:
1292       {
1293         format = 0;
1294       }
1295     }
1296   }
1297
1298   /**
1299    * @brief Explicit type conversion operator
1300    * @return converted value
1301    */
1302   constexpr inline operator GLenum() const
1303   {
1304     return format;
1305   }
1306
1307   GLenum format{0}; ///< Converted format
1308 };
1309
1310 /**
1311  * @brief Conversion of blending function factor
1312  */
1313 struct GLBlendFunc
1314 {
1315   constexpr explicit GLBlendFunc(Graphics::BlendFactor factor)
1316   {
1317     switch(factor)
1318     {
1319       case Graphics::BlendFactor::ZERO:
1320       {
1321         glFactor = GL_ZERO;
1322         break;
1323       }
1324       case Graphics::BlendFactor::ONE:
1325       {
1326         glFactor = GL_ONE;
1327         break;
1328       }
1329       case Graphics::BlendFactor::SRC_COLOR:
1330       {
1331         glFactor = GL_SRC_COLOR;
1332         break;
1333       }
1334       case Graphics::BlendFactor::ONE_MINUS_SRC_COLOR:
1335       {
1336         glFactor = GL_ONE_MINUS_SRC_COLOR;
1337         break;
1338       }
1339       case Graphics::BlendFactor::DST_COLOR:
1340       {
1341         glFactor = GL_DST_COLOR;
1342         break;
1343       }
1344       case Graphics::BlendFactor::ONE_MINUS_DST_COLOR:
1345       {
1346         glFactor = GL_ONE_MINUS_DST_COLOR;
1347         break;
1348       }
1349       case Graphics::BlendFactor::SRC_ALPHA:
1350       {
1351         glFactor = GL_SRC_ALPHA;
1352         break;
1353       }
1354       case Graphics::BlendFactor::ONE_MINUS_SRC_ALPHA:
1355       {
1356         glFactor = GL_ONE_MINUS_SRC_ALPHA;
1357         break;
1358       }
1359       case Graphics::BlendFactor::DST_ALPHA:
1360       {
1361         glFactor = GL_DST_ALPHA;
1362         break;
1363       }
1364       case Graphics::BlendFactor::ONE_MINUS_DST_ALPHA:
1365       {
1366         glFactor = GL_ONE_MINUS_DST_ALPHA;
1367         break;
1368       }
1369       case Graphics::BlendFactor::CONSTANT_COLOR:
1370       {
1371         glFactor = GL_CONSTANT_COLOR;
1372         break;
1373       }
1374       case Graphics::BlendFactor::ONE_MINUS_CONSTANT_COLOR:
1375       {
1376         glFactor = GL_ONE_MINUS_CONSTANT_COLOR;
1377         break;
1378       }
1379       case Graphics::BlendFactor::CONSTANT_ALPHA:
1380       {
1381         glFactor = GL_CONSTANT_ALPHA;
1382         break;
1383       }
1384       case Graphics::BlendFactor::ONE_MINUS_CONSTANT_ALPHA:
1385       {
1386         glFactor = GL_ONE_MINUS_CONSTANT_ALPHA;
1387         break;
1388       }
1389       case Graphics::BlendFactor::SRC_ALPHA_SATURATE:
1390       {
1391         glFactor = GL_SRC_ALPHA_SATURATE;
1392         break;
1393       }
1394       // Below may be unsupported without extension
1395       case Graphics::BlendFactor::SRC1_COLOR:
1396       {
1397         glFactor = 0u;
1398         break;
1399       }
1400       case Graphics::BlendFactor::ONE_MINUS_SRC1_COLOR:
1401       {
1402         glFactor = 0u;
1403         break;
1404       }
1405       case Graphics::BlendFactor::SRC1_ALPHA:
1406       {
1407         glFactor = 0u;
1408         break;
1409       }
1410       case Graphics::BlendFactor::ONE_MINUS_SRC1_ALPHA:
1411       {
1412         glFactor = 0u;
1413         break;
1414       }
1415     }
1416   }
1417
1418   /**
1419    * @brief Explicit type conversion operator
1420    * @return converted value
1421    */
1422   constexpr inline operator GLenum() const
1423   {
1424     return glFactor;
1425   }
1426
1427   GLenum glFactor{0u};
1428 };
1429
1430 /**
1431  * @brief Converts Blend Op to GL
1432  */
1433 struct GLBlendOp
1434 {
1435   constexpr explicit GLBlendOp(Graphics::BlendOp blendOp)
1436   {
1437     switch(blendOp)
1438     {
1439       case Graphics::BlendOp::ADD:
1440       {
1441         glBlendOp = GL_FUNC_ADD;
1442         break;
1443       }
1444       case Graphics::BlendOp::SUBTRACT:
1445       {
1446         glBlendOp = GL_FUNC_SUBTRACT;
1447         break;
1448       }
1449       case Graphics::BlendOp::REVERSE_SUBTRACT:
1450       {
1451         glBlendOp = GL_FUNC_REVERSE_SUBTRACT;
1452         break;
1453       }
1454       case Graphics::BlendOp::MIN:
1455       {
1456         glBlendOp = GL_MIN;
1457         break;
1458       }
1459       case Graphics::BlendOp::MAX:
1460       {
1461         glBlendOp = GL_MAX;
1462         break;
1463       }
1464       case Graphics::BlendOp::MULTIPLY:
1465       {
1466         glBlendOp = GL_MULTIPLY;
1467         break;
1468       }
1469       case Graphics::BlendOp::SCREEN:
1470       {
1471         glBlendOp = GL_SCREEN;
1472         break;
1473       }
1474       case Graphics::BlendOp::OVERLAY:
1475       {
1476         glBlendOp = GL_OVERLAY;
1477         break;
1478       }
1479       case Graphics::BlendOp::DARKEN:
1480       {
1481         glBlendOp = GL_DARKEN;
1482         break;
1483       }
1484       case Graphics::BlendOp::LIGHTEN:
1485       {
1486         glBlendOp = GL_LIGHTEN;
1487         break;
1488       }
1489       case Graphics::BlendOp::COLOR_DODGE:
1490       {
1491         glBlendOp = GL_COLORDODGE;
1492         break;
1493       }
1494       case Graphics::BlendOp::COLOR_BURN:
1495       {
1496         glBlendOp = GL_COLORBURN;
1497         break;
1498       }
1499       case Graphics::BlendOp::HARD_LIGHT:
1500       {
1501         glBlendOp = GL_HARDLIGHT;
1502         break;
1503       }
1504       case Graphics::BlendOp::SOFT_LIGHT:
1505       {
1506         glBlendOp = GL_SOFTLIGHT;
1507         break;
1508       }
1509       case Graphics::BlendOp::DIFFERENCE:
1510       {
1511         glBlendOp = GL_DIFFERENCE;
1512         break;
1513       }
1514       case Graphics::BlendOp::EXCLUSION:
1515       {
1516         glBlendOp = GL_EXCLUSION;
1517         break;
1518       }
1519       case Graphics::BlendOp::HUE:
1520       {
1521         glBlendOp = GL_HSL_HUE;
1522         break;
1523       }
1524       case Graphics::BlendOp::SATURATION:
1525       {
1526         glBlendOp = GL_HSL_SATURATION;
1527         break;
1528       }
1529       case Graphics::BlendOp::COLOR:
1530       {
1531         glBlendOp = GL_HSL_COLOR;
1532         break;
1533       }
1534       case Graphics::BlendOp::LUMINOSITY:
1535       {
1536         glBlendOp = GL_HSL_LUMINOSITY;
1537         break;
1538       }
1539     }
1540   }
1541
1542   /**
1543    * @brief Explicit type conversion operator
1544    * @return converted value
1545    */
1546   constexpr inline operator GLenum() const
1547   {
1548     return glBlendOp;
1549   }
1550
1551   GLenum glBlendOp{0u};
1552 };
1553
1554 /**
1555  * @brief Converts GL cull mode
1556  */
1557 struct GLCullMode
1558 {
1559   constexpr explicit GLCullMode(Graphics::CullMode cullMode)
1560   {
1561     switch(cullMode)
1562     {
1563       case Graphics::CullMode::NONE: // this isn't really accepted by GL!
1564       {
1565         glCullMode = GL_NONE;
1566         break;
1567       }
1568       case Graphics::CullMode::FRONT:
1569       {
1570         glCullMode = GL_FRONT;
1571         break;
1572       }
1573       case Graphics::CullMode::BACK:
1574       {
1575         glCullMode = GL_BACK;
1576         break;
1577       }
1578       case Graphics::CullMode::FRONT_AND_BACK:
1579       {
1580         glCullMode = GL_FRONT_AND_BACK;
1581         break;
1582       }
1583     }
1584   }
1585
1586   /**
1587    * @brief Explicit type conversion operator
1588    * @return converted value
1589    */
1590   constexpr inline operator GLenum() const
1591   {
1592     return glCullMode;
1593   }
1594
1595   GLenum glCullMode{0u};
1596 };
1597
1598 /**
1599  * @brief enum with GL types
1600  */
1601 enum class GLType
1602 {
1603   UNDEFINED      = 0x0,
1604   FLOAT_VEC2     = 0x8B50,
1605   FLOAT_VEC3     = 0x8B51,
1606   FLOAT_VEC4     = 0x8B52,
1607   INT_VEC2       = 0x8B53,
1608   INT_VEC3       = 0x8B54,
1609   INT_VEC4       = 0x8B55,
1610   BOOL           = 0x8B56,
1611   BOOL_VEC2      = 0x8B57,
1612   BOOL_VEC3      = 0x8B58,
1613   BOOL_VEC4      = 0x8B59,
1614   FLOAT_MAT2     = 0x8B5A,
1615   FLOAT_MAT3     = 0x8B5B,
1616   FLOAT_MAT4     = 0x8B5C,
1617   SAMPLER_2D     = 0x8B5E,
1618   SAMPLER_CUBE   = 0x8B60,
1619   BYTE           = 0x1400,
1620   UNSIGNED_BYTE  = 0x1401,
1621   SHORT          = 0x1402,
1622   UNSIGNED_SHORT = 0x1403,
1623   INT            = 0x1404,
1624   UNSIGNED_INT   = 0x1405,
1625   FLOAT          = 0x1406,
1626   FIXED          = 0x140C,
1627 };
1628
1629 /**
1630  * @brief GL type conversion (used with reflection)
1631  */
1632 struct GLTypeConversion
1633 {
1634   constexpr explicit GLTypeConversion(GLenum value)
1635   {
1636     switch(value)
1637     {
1638       case GL_FLOAT_VEC2:
1639       {
1640         type = GLType::FLOAT_VEC2;
1641         break;
1642       }
1643       case GL_FLOAT_VEC3:
1644       {
1645         type = GLType::FLOAT_VEC3;
1646         break;
1647       }
1648       case GL_FLOAT_VEC4:
1649       {
1650         type = GLType::FLOAT_VEC4;
1651         break;
1652       }
1653       case GL_INT_VEC2:
1654       {
1655         type = GLType::INT_VEC2;
1656         break;
1657       }
1658       case GL_INT_VEC3:
1659       {
1660         type = GLType::INT_VEC3;
1661         break;
1662       }
1663       case GL_INT_VEC4:
1664       {
1665         type = GLType::INT_VEC4;
1666         break;
1667       }
1668       case GL_BOOL:
1669       {
1670         type = GLType::BOOL;
1671         break;
1672       }
1673       case GL_BOOL_VEC2:
1674       {
1675         type = GLType::BOOL_VEC2;
1676         break;
1677       }
1678       case GL_BOOL_VEC3:
1679       {
1680         type = GLType::BOOL_VEC3;
1681         break;
1682       }
1683       case GL_BOOL_VEC4:
1684       {
1685         type = GLType::BOOL_VEC4;
1686         break;
1687       }
1688       case GL_FLOAT_MAT2:
1689       {
1690         type = GLType::FLOAT_MAT2;
1691         break;
1692       }
1693       case GL_FLOAT_MAT3:
1694       {
1695         type = GLType::FLOAT_MAT3;
1696         break;
1697       }
1698       case GL_FLOAT_MAT4:
1699       {
1700         type = GLType::FLOAT_MAT4;
1701         break;
1702       }
1703       case GL_SAMPLER_2D:
1704       {
1705         type = GLType::SAMPLER_2D;
1706         break;
1707       }
1708       case GL_SAMPLER_CUBE:
1709       {
1710         type = GLType::SAMPLER_CUBE;
1711         break;
1712       }
1713       case GL_FLOAT:
1714       {
1715         type = GLType::FLOAT;
1716         break;
1717       }
1718       case GL_INT:
1719       {
1720         type = GLType::INT;
1721         break;
1722       }
1723       default:
1724       {
1725         type = GLType::UNDEFINED;
1726       }
1727     }
1728   }
1729
1730   GLType type{GLType::UNDEFINED};
1731 };
1732
1733 enum class GLESVersion
1734 {
1735   GLES_20 = 20,
1736   GLES_30 = 30,
1737   GLES_31 = 31,
1738   GLES_32 = 32
1739 };
1740
1741 /**
1742  * @brief Types of bond texture cached in the context
1743  */
1744 enum class BoundTextureType
1745 {
1746   TEXTURE_2D,
1747   TEXTURE_3D,
1748   TEXTURE_CUBEMAP,
1749   TEXTURE_EXTERNAL_OES
1750 };
1751
1752 /**
1753  * This class stores indirect pointer, used by the CommandBuffer
1754  * to store data allocated within resizeable pool
1755  */
1756 template<class T>
1757 struct IndirectPtr
1758 {
1759   uint32_t ptr;  // relative pointer
1760   void**   base; // base pointer
1761
1762   inline T* operator->()
1763   {
1764     return reinterpret_cast<T*>((reinterpret_cast<uint8_t*>(*base) + ptr));
1765   }
1766
1767   inline T& operator*()
1768   {
1769     return *reinterpret_cast<T*>((reinterpret_cast<uint8_t*>(*base) + ptr));
1770   }
1771
1772   // Returns indirect pointer casted to requested type
1773   T* Ptr() const
1774   {
1775     auto val = reinterpret_cast<T*>((reinterpret_cast<uint8_t*>(*base) + ptr));
1776     return val;
1777   }
1778
1779   inline T& operator[](int index)
1780   {
1781     return reinterpret_cast<T*>((reinterpret_cast<uint8_t*>(*base) + ptr))[index];
1782   }
1783
1784   // Fake assignment operator for void* type
1785   inline IndirectPtr<T>& operator=(void* p)
1786   {
1787     ptr  = 0;
1788     base = nullptr;
1789     return *this;
1790   }
1791 };
1792
1793 /**
1794  * The descriptor of BeginRenderPass command
1795  */
1796 struct BeginRenderPassDescriptor
1797 {
1798   const GLES::RenderPass*   renderPass;
1799   const GLES::RenderTarget* renderTarget;
1800   Rect2D                    renderArea;
1801   IndirectPtr<ClearValue>   clearValues;
1802   uint32_t                  clearValuesCount;
1803 };
1804
1805 } // namespace Dali::Graphics::GLES
1806
1807 #endif //DALI_GRAPHICS_API_TYPES_H