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