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       {
 214         Assign(0, 0);
 215         break;
 216       }
 217       case Graphics::Format::B8G8R8_SNORM:
 218       {
 219         Assign(0, 0);
 220         break;
 221       }
 222       case Graphics::Format::B8G8R8_USCALED:
 223       {
 224         Assign(0, 0);
 225         break;
 226       }
 227       case Graphics::Format::B8G8R8_SSCALED:
 228       {
 229         Assign(0, 0);
 230         break;
 231       }
 232       case Graphics::Format::B8G8R8_UINT:
 233       {
 234         Assign(0, 0);
 235         break;
 236       }
 237       case Graphics::Format::B8G8R8_SINT:
 238       {
 239         Assign(0, 0);
 240         break;
 241       }
 242       case Graphics::Format::B8G8R8_SRGB:
 243       {
 244         Assign(0, 0);
 245         break;
 246       }
 247
 248       // RGBA
 249       case Graphics::Format::R8G8B8A8_UNORM:
 250       {
 251         Assign(GL_RGBA, GL_UNSIGNED_BYTE);
 252         break;
 253       }
 254       case Graphics::Format::R8G8B8A8_SNORM:
 255       {
 256         Assign(GL_RGBA, GL_BYTE);
 257         break;
 258       }
 259       case Graphics::Format::R8G8B8A8_USCALED:
 260       {
 261         Assign(GL_RGBA, GL_UNSIGNED_BYTE);
 262         break;
 263       }
 264       case Graphics::Format::R8G8B8A8_SSCALED:
 265       {
 266         Assign(GL_RGBA, GL_BYTE);
 267         break;
 268       }
 269       case Graphics::Format::R8G8B8A8_UINT:
 270       {
 271         Assign(GL_RGBA, GL_UNSIGNED_BYTE);
 272         break;
 273       }
 274       case Graphics::Format::R8G8B8A8_SINT:
 275       {
 276         Assign(GL_RGBA, GL_BYTE);
 277         break;
 278       }
 279       case Graphics::Format::R8G8B8A8_SRGB:
 280       {
 281         Assign(GL_RGBA, GL_BYTE);
 282         break;
 283       }
 284
 285       // BGRA when only support GL_BGRA_EXT. otherwise, use RGBA
 286       case Graphics::Format::B8G8R8A8_UNORM:
 287       {
 288 #ifdef GL_BGRA_EXT
 289         Assign(GL_BGRA_EXT, GL_UNSIGNED_BYTE);
 290 #else
 291         Assign(GL_RGBA, GL_UNSIGNED_BYTE);
 292 #endif
 293         break;
 294       }
 295       case Graphics::Format::B8G8R8A8_SNORM:
 296       {
 297 #ifdef GL_BGRA_EXT
 298         Assign(GL_BGRA_EXT, GL_BYTE);
 299 #else
 300         Assign(GL_RGBA, GL_BYTE);
 301 #endif
 302         break;
 303       }
 304       case Graphics::Format::B8G8R8A8_USCALED:
 305       {
 306 #ifdef GL_BGRA_EXT
 307         Assign(GL_BGRA_EXT, GL_UNSIGNED_BYTE);
 308 #else
 309         Assign(GL_RGBA, GL_UNSIGNED_BYTE);
 310 #endif
 311         break;
 312       }
 313       case Graphics::Format::B8G8R8A8_SSCALED:
 314       {
 315 #ifdef GL_BGRA_EXT
 316         Assign(GL_BGRA_EXT, GL_BYTE);
 317 #else
 318         Assign(GL_RGBA, GL_BYTE);
 319 #endif
 320         break;
 321       }
 322       case Graphics::Format::B8G8R8A8_UINT:
 323       {
 324 #ifdef GL_BGRA_EXT
 325         Assign(GL_BGRA_EXT, GL_UNSIGNED_BYTE);
 326 #else
 327         Assign(GL_RGBA, GL_UNSIGNED_BYTE);
 328 #endif
 329         break;
 330       }
 331       case Graphics::Format::B8G8R8A8_SINT:
 332       {
 333 #ifdef GL_BGRA_EXT
 334         Assign(GL_BGRA_EXT, GL_BYTE);
 335 #else
 336         Assign(GL_RGBA, GL_BYTE);
 337 #endif
 338         break;
 339       }
 340       case Graphics::Format::B8G8R8A8_SRGB:
 341       {
 342 #ifdef GL_BGRA_EXT
 343         Assign(GL_BGRA_EXT, GL_BYTE);
 344 #else
 345         Assign(GL_RGBA, GL_BYTE);
 346 #endif
 347         break;
 348       }
 349
 350       // ABGR not supported
 351       case Graphics::Format::A8B8G8R8_UNORM_PACK32:
 352       {
 353         Assign(0, 0);
 354         break;
 355       }
 356       case Graphics::Format::A8B8G8R8_SNORM_PACK32:
 357       {
 358         Assign(0, 0);
 359         break;
 360       }
 361       case Graphics::Format::A8B8G8R8_USCALED_PACK32:
 362       {
 363         Assign(0, 0);
 364         break;
 365       }
 366       case Graphics::Format::A8B8G8R8_SSCALED_PACK32:
 367       {
 368         Assign(0, 0);
 369         break;
 370       }
 371       case Graphics::Format::A8B8G8R8_UINT_PACK32:
 372       {
 373         Assign(0, 0);
 374         break;
 375       }
 376       case Graphics::Format::A8B8G8R8_SINT_PACK32:
 377       {
 378         Assign(0, 0);
 379         break;
 380       }
 381       case Graphics::Format::A8B8G8R8_SRGB_PACK32:
 382       {
 383         Assign(0, 0);
 384         break;
 385       }
 386
 387       // TBD which of the formats are supported
 388       case Graphics::Format::A2R10G10B10_UNORM_PACK32:
 389       {
 390         Assign(0, 0);
 391         break;
 392       }
 393       case Graphics::Format::A2R10G10B10_SNORM_PACK32:
 394       {
 395         Assign(0, 0);
 396         break;
 397       }
 398       case Graphics::Format::A2R10G10B10_USCALED_PACK32:
 399       {
 400         Assign(0, 0);
 401         break;
 402       }
 403       case Graphics::Format::A2R10G10B10_SSCALED_PACK32:
 404       {
 405         Assign(0, 0);
 406         break;
 407       }
 408       case Graphics::Format::A2R10G10B10_UINT_PACK32:
 409       {
 410         Assign(0, 0);
 411         break;
 412       }
 413       case Graphics::Format::A2R10G10B10_SINT_PACK32:
 414       {
 415         Assign(0, 0);
 416         break;
 417       }
 418       case Graphics::Format::A2B10G10R10_UNORM_PACK32:
 419       {
 420         Assign(0, 0);
 421         break;
 422       }
 423       case Graphics::Format::A2B10G10R10_SNORM_PACK32:
 424       {
 425         Assign(0, 0);
 426         break;
 427       }
 428       case Graphics::Format::A2B10G10R10_USCALED_PACK32:
 429       {
 430         Assign(0, 0);
 431         break;
 432       }
 433       case Graphics::Format::A2B10G10R10_SSCALED_PACK32:
 434       {
 435         Assign(0, 0);
 436         break;
 437       }
 438       case Graphics::Format::A2B10G10R10_UINT_PACK32:
 439       {
 440         Assign(0, 0);
 441         break;
 442       }
 443       case Graphics::Format::A2B10G10R10_SINT_PACK32:
 444       {
 445         Assign(0, 0);
 446         break;
 447       }
 448       case Graphics::Format::R16_UNORM:
 449       {
 450         Assign(0, 0);
 451         break;
 452       }
 453       case Graphics::Format::R16_SNORM:
 454       {
 455         Assign(0, 0);
 456         break;
 457       }
 458       case Graphics::Format::R16_USCALED:
 459       {
 460         Assign(0, 0);
 461         break;
 462       }
 463       case Graphics::Format::R16_SSCALED:
 464       {
 465         Assign(0, 0);
 466         break;
 467       }
 468       case Graphics::Format::R16_UINT:
 469       {
 470         Assign(0, 0);
 471         break;
 472       }
 473       case Graphics::Format::R16_SINT:
 474       {
 475         Assign(0, 0);
 476         break;
 477       }
 478       case Graphics::Format::R16_SFLOAT:
 479       {
 480         Assign(0, 0);
 481         break;
 482       }
 483       case Graphics::Format::R16G16_UNORM:
 484       {
 485         Assign(0, 0);
 486         break;
 487       }
 488       case Graphics::Format::R16G16_SNORM:
 489       {
 490         Assign(0, 0);
 491         break;
 492       }
 493       case Graphics::Format::R16G16_USCALED:
 494       {
 495         Assign(0, 0);
 496         break;
 497       }
 498       case Graphics::Format::R16G16_SSCALED:
 499       {
 500         Assign(0, 0);
 501         break;
 502       }
 503       case Graphics::Format::R16G16_UINT:
 504       {
 505         Assign(0, 0);
 506         break;
 507       }
 508       case Graphics::Format::R16G16_SINT:
 509       {
 510         Assign(0, 0);
 511         break;
 512       }
 513       case Graphics::Format::R16G16_SFLOAT:
 514       {
 515         Assign(0, 0);
 516         break;
 517       }
 518       case Graphics::Format::R16G16B16_UNORM:
 519       {
 520         Assign(0, 0);
 521         break;
 522       }
 523       case Graphics::Format::R16G16B16_SNORM:
 524       {
 525         Assign(0, 0);
 526         break;
 527       }
 528       case Graphics::Format::R16G16B16_USCALED:
 529       {
 530         Assign(0, 0);
 531         break;
 532       }
 533       case Graphics::Format::R16G16B16_SSCALED:
 534       {
 535         Assign(0, 0);
 536         break;
 537       }
 538       case Graphics::Format::R16G16B16_UINT:
 539       {
 540         Assign(0, 0);
 541         break;
 542       }
 543       case Graphics::Format::R16G16B16_SINT:
 544       {
 545         Assign(0, 0);
 546         break;
 547       }
 548       case Graphics::Format::R16G16B16_SFLOAT:
 549       {
 550         // GLES 3.0 floating point formats.
 551         AssignInternal(GL_RGB, GL_R11F_G11F_B10F, GL_HALF_FLOAT); // DALi uses compact internal format
 552         break;
 553       }
 554       case Graphics::Format::R16G16B16A16_UNORM:
 555       {
 556         Assign(0, 0);
 557         break;
 558       }
 559       case Graphics::Format::R16G16B16A16_SNORM:
 560       {
 561         Assign(0, 0);
 562         break;
 563       }
 564       case Graphics::Format::R16G16B16A16_USCALED:
 565       {
 566         Assign(0, 0);
 567         break;
 568       }
 569       case Graphics::Format::R16G16B16A16_SSCALED:
 570       {
 571         Assign(0, 0);
 572         break;
 573       }
 574       case Graphics::Format::R16G16B16A16_UINT:
 575       {
 576         Assign(0, 0);
 577         break;
 578       }
 579       case Graphics::Format::R16G16B16A16_SINT:
 580       {
 581         Assign(0, 0);
 582         break;
 583       }
 584       case Graphics::Format::R16G16B16A16_SFLOAT:
 585       {
 586         Assign(0, 0);
 587         break;
 588       }
 589       case Graphics::Format::R32_UINT:
 590       {
 591         Assign(0, 0);
 592         break;
 593       }
 594       case Graphics::Format::R32_SINT:
 595       {
 596         Assign(0, 0);
 597         break;
 598       }
 599       case Graphics::Format::R32_SFLOAT:
 600       {
 601         Assign(0, 0);
 602         break;
 603       }
 604       case Graphics::Format::R32G32_UINT:
 605       {
 606         Assign(0, 0);
 607         break;
 608       }
 609       case Graphics::Format::R32G32_SINT:
 610       {
 611         Assign(0, 0);
 612         break;
 613       }
 614       case Graphics::Format::R32G32_SFLOAT:
 615       {
 616         Assign(0, 0);
 617         break;
 618       }
 619       case Graphics::Format::R32G32B32_UINT:
 620       {
 621         Assign(0, 0);
 622         break;
 623       }
 624       case Graphics::Format::R32G32B32_SINT:
 625       {
 626         Assign(0, 0);
 627         break;
 628       }
 629       case Graphics::Format::R32G32B32_SFLOAT:
 630       {
 631         AssignInternal(GL_RGB, GL_R11F_G11F_B10F, GL_FLOAT); // DALi uses compact internal format
 632         break;
 633       }
 634       case Graphics::Format::R32G32B32A32_UINT:
 635       {
 636         Assign(0, 0);
 637         break;
 638       }
 639       case Graphics::Format::R32G32B32A32_SINT:
 640       {
 641         Assign(0, 0);
 642         break;
 643       }
 644       case Graphics::Format::R32G32B32A32_SFLOAT:
 645       {
 646         Assign(0, 0);
 647         break;
 648       }
 649       case Graphics::Format::R64_UINT:
 650       {
 651         Assign(0, 0);
 652         break;
 653       }
 654       case Graphics::Format::R64_SINT:
 655       {
 656         Assign(0, 0);
 657         break;
 658       }
 659       case Graphics::Format::R64_SFLOAT:
 660       {
 661         Assign(0, 0);
 662         break;
 663       }
 664       case Graphics::Format::R64G64_UINT:
 665       {
 666         Assign(0, 0);
 667         break;
 668       }
 669       case Graphics::Format::R64G64_SINT:
 670       {
 671         Assign(0, 0);
 672         break;
 673       }
 674       case Graphics::Format::R64G64_SFLOAT:
 675       {
 676         Assign(0, 0);
 677         break;
 678       }
 679       case Graphics::Format::R64G64B64_UINT:
 680       {
 681         Assign(0, 0);
 682         break;
 683       }
 684       case Graphics::Format::R64G64B64_SINT:
 685       {
 686         Assign(0, 0);
 687         break;
 688       }
 689       case Graphics::Format::R64G64B64_SFLOAT:
 690       {
 691         Assign(0, 0);
 692         break;
 693       }
 694       case Graphics::Format::R64G64B64A64_UINT:
 695       {
 696         Assign(0, 0);
 697         break;
 698       }
 699       case Graphics::Format::R64G64B64A64_SINT:
 700       {
 701         Assign(0, 0);
 702         break;
 703       }
 704       case Graphics::Format::R64G64B64A64_SFLOAT:
 705       {
 706         Assign(0, 0);
 707         break;
 708       }
 709       case Graphics::Format::R11G11B10_UFLOAT_PACK32:
 710       {
 711         AssignInternal(GL_RGB, GL_R11F_G11F_B10F, GL_FLOAT);
 712         break;
 713       }
 714       case Graphics::Format::B10G11R11_UFLOAT_PACK32:
 715       {
 716         Assign(0, 0);
 717         break;
 718       }
 719       case Graphics::Format::E5B9G9R9_UFLOAT_PACK32:
 720       {
 721         Assign(0, 0);
 722         break;
 723       }
 724       case Graphics::Format::D16_UNORM:
 725       {
 726         // GLES 3.0 depth and stencil formats
 727         Assign(GL_DEPTH_COMPONENT, GL_UNSIGNED_INT);
 728         break;
 729       }
 730       case Graphics::Format::X8_D24_UNORM_PACK32:
 731       {
 732         Assign(0, 0);
 733         break;
 734       }
 735       case Graphics::Format::D32_SFLOAT:
 736       {
 737         // GLES 3.0 depth and stencil formats
 738         AssignInternal(GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT32F, GL_FLOAT);
 739         break;
 740       }
 741       case Graphics::Format::S8_UINT:
 742       {
 743         Assign(0, 0);
 744         break;
 745       }
 746       case Graphics::Format::D16_UNORM_S8_UINT:
 747       {
 748         Assign(0, 0);
 749         break;
 750       }
 751       case Graphics::Format::D24_UNORM_S8_UINT:
 752       {
 753         // GLES 3.0 depth and stencil formats
 754         AssignInternal(GL_DEPTH_STENCIL, GL_DEPTH24_STENCIL8, GL_UNSIGNED_INT_24_8);
 755         break;
 756       }
 757       case Graphics::Format::D32_SFLOAT_S8_UINT:
 758       {
 759         Assign(0, 0);
 760         break;
 761       }
 762       case Graphics::Format::BC1_RGB_UNORM_BLOCK:
 763       {
 764         Assign(0, 0);
 765         break;
 766       }
 767       case Graphics::Format::BC1_RGB_SRGB_BLOCK:
 768       {
 769         Assign(0, 0);
 770         break;
 771       }
 772       case Graphics::Format::BC1_RGBA_UNORM_BLOCK:
 773       {
 774         Assign(0, 0);
 775         break;
 776       }
 777       case Graphics::Format::BC1_RGBA_SRGB_BLOCK:
 778       {
 779         Assign(0, 0);
 780         break;
 781       }
 782       case Graphics::Format::BC2_UNORM_BLOCK:
 783       {
 784         Assign(0, 0);
 785         break;
 786       }
 787       case Graphics::Format::BC2_SRGB_BLOCK:
 788       {
 789         Assign(0, 0);
 790         break;
 791       }
 792       case Graphics::Format::BC3_UNORM_BLOCK:
 793       {
 794         Assign(0, 0);
 795         break;
 796       }
 797       case Graphics::Format::BC3_SRGB_BLOCK:
 798       {
 799         Assign(0, 0);
 800         break;
 801       }
 802       case Graphics::Format::BC4_UNORM_BLOCK:
 803       {
 804         Assign(0, 0);
 805         break;
 806       }
 807       case Graphics::Format::BC4_SNORM_BLOCK:
 808       {
 809         Assign(0, 0);
 810         break;
 811       }
 812       case Graphics::Format::BC5_UNORM_BLOCK:
 813       {
 814         Assign(0, 0);
 815         break;
 816       }
 817       case Graphics::Format::BC5_SNORM_BLOCK:
 818       {
 819         Assign(0, 0);
 820         break;
 821       }
 822       case Graphics::Format::BC6H_UFLOAT_BLOCK:
 823       {
 824         Assign(0, 0);
 825         break;
 826       }
 827       case Graphics::Format::BC6H_SFLOAT_BLOCK:
 828       {
 829         Assign(0, 0);
 830         break;
 831       }
 832       case Graphics::Format::BC7_UNORM_BLOCK:
 833       {
 834         Assign(0, 0);
 835         break;
 836       }
 837       case Graphics::Format::BC7_SRGB_BLOCK:
 838       {
 839         Assign(0, 0);
 840         break;
 841       }
 842       case Graphics::Format::ETC2_R8G8B8_UNORM_BLOCK:
 843       {
 844         ///! Using GLES 3.0 standard compressed pixel format COMPRESSED_RGB8_ETC2.
 845         Assign(GL_COMPRESSED_RGB8_ETC2, 0);
 846         break;
 847       }
 848       case Graphics::Format::ETC2_R8G8B8_SRGB_BLOCK:
 849       {
 850         ///! Using GLES 3.0 standard compressed pixel format COMPRESSED_SRGB8_ETC2.
 851         Assign(GL_COMPRESSED_SRGB8_ETC2, 0);
 852         break;
 853       }
 854       case Graphics::Format::ETC2_R8G8B8A1_UNORM_BLOCK:
 855       {
 856         ///! Using GLES 3.0 standard compressed pixel format COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2.
 857         Assign(GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, 0);
 858         break;
 859       }
 860       case Graphics::Format::ETC2_R8G8B8A1_SRGB_BLOCK:
 861       {
 862         ///! Using GLES 3.0 standard compressed pixel format COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2.
 863         Assign(GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, 0);
 864         break;
 865       }
 866       case Graphics::Format::ETC2_R8G8B8A8_UNORM_BLOCK:
 867       {
 868         Assign(GL_COMPRESSED_RGBA8_ETC2_EAC, 0);
 869         break;
 870       }
 871       case Graphics::Format::ETC2_R8G8B8A8_SRGB_BLOCK:
 872       {
 873         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, 0);
 874         break;
 875       }
 876       case Graphics::Format::EAC_R11_UNORM_BLOCK:
 877       {
 878         ///! Using GLES 3.0 standard compressed pixel format COMPRESSED_R11_EAC.
 879         Assign(GL_COMPRESSED_R11_EAC, 0);
 880         break;
 881       }
 882       case Graphics::Format::EAC_R11_SNORM_BLOCK:
 883       {
 884         ///! Using GLES 3.0 standard compressed pixel format COMPRESSED_SIGNED_R11_EAC.
 885         Assign(GL_COMPRESSED_SIGNED_R11_EAC, 0);
 886         break;
 887       }
 888       case Graphics::Format::EAC_R11G11_UNORM_BLOCK:
 889       {
 890         ///! Using GLES 3.0 standard compressed pixel format COMPRESSED_RG11_EAC.
 891         Assign(GL_COMPRESSED_RG11_EAC, 0);
 892         break;
 893       }
 894       case Graphics::Format::EAC_R11G11_SNORM_BLOCK:
 895       {
 896         ///! Using GLES 3.0 standard compressed pixel format COMPRESSED_SIGNED_RG11_EAC.
 897         Assign(GL_COMPRESSED_SIGNED_RG11_EAC, 0);
 898         break;
 899       }
 900       case Graphics::Format::ASTC_4x4_UNORM_BLOCK:
 901       {
 902         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_4x4_KHR.
 903         Assign(GL_COMPRESSED_RGBA_ASTC_4x4_KHR, 0);
 904         break;
 905       }
 906       case Graphics::Format::ASTC_4x4_SRGB_BLOCK:
 907       {
 908         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR.
 909         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR, 0);
 910         break;
 911       }
 912       case Graphics::Format::ASTC_5x4_UNORM_BLOCK:
 913       {
 914         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_5x4_KHR.
 915         Assign(GL_COMPRESSED_RGBA_ASTC_5x4_KHR, 0);
 916         break;
 917       }
 918       case Graphics::Format::ASTC_5x4_SRGB_BLOCK:
 919       {
 920         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR.
 921         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR, 0);
 922         break;
 923       }
 924       case Graphics::Format::ASTC_5x5_UNORM_BLOCK:
 925       {
 926         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_5x5_KHR.
 927         Assign(GL_COMPRESSED_RGBA_ASTC_5x5_KHR, 0);
 928         break;
 929       }
 930       case Graphics::Format::ASTC_5x5_SRGB_BLOCK:
 931       {
 932         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR.
 933         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR, 0);
 934         break;
 935       }
 936       case Graphics::Format::ASTC_6x5_UNORM_BLOCK:
 937       {
 938         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_6x5_KHR.
 939         Assign(GL_COMPRESSED_RGBA_ASTC_6x5_KHR, 0);
 940         break;
 941       }
 942       case Graphics::Format::ASTC_6x5_SRGB_BLOCK:
 943       {
 944         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR.
 945         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR, 0);
 946         break;
 947       }
 948       case Graphics::Format::ASTC_6x6_UNORM_BLOCK:
 949       {
 950         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_6x6_KHR.
 951         Assign(GL_COMPRESSED_RGBA_ASTC_6x6_KHR, 0);
 952         break;
 953       }
 954       case Graphics::Format::ASTC_6x6_SRGB_BLOCK:
 955       {
 956         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR.
 957         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR, 0);
 958         break;
 959       }
 960       case Graphics::Format::ASTC_8x5_UNORM_BLOCK:
 961       {
 962         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_8x5_KHR.
 963         Assign(GL_COMPRESSED_RGBA_ASTC_8x5_KHR, 0);
 964         break;
 965       }
 966       case Graphics::Format::ASTC_8x5_SRGB_BLOCK:
 967       {
 968         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR.
 969         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR, 0);
 970         break;
 971       }
 972       case Graphics::Format::ASTC_8x6_UNORM_BLOCK:
 973       {
 974         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_8x6_KHR.
 975         Assign(GL_COMPRESSED_RGBA_ASTC_8x6_KHR, 0);
 976         break;
 977       }
 978       case Graphics::Format::ASTC_8x6_SRGB_BLOCK:
 979       {
 980         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR.
 981         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR, 0);
 982         break;
 983       }
 984       case Graphics::Format::ASTC_8x8_UNORM_BLOCK:
 985       {
 986         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_8x8_KHR.
 987         Assign(GL_COMPRESSED_RGBA_ASTC_8x8_KHR, 0);
 988         break;
 989       }
 990       case Graphics::Format::ASTC_8x8_SRGB_BLOCK:
 991       {
 992         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR.
 993         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR, 0);
 994         break;
 995       }
 996       case Graphics::Format::ASTC_10x5_UNORM_BLOCK:
 997       {
 998         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_10x5_KHR.
 999         Assign(GL_COMPRESSED_RGBA_ASTC_10x5_KHR, 0);
1000         break;
1001       }
1002       case Graphics::Format::ASTC_10x5_SRGB_BLOCK:
1003       {
1004         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR.
1005         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR, 0);
1006         break;
1007       }
1008       case Graphics::Format::ASTC_10x6_UNORM_BLOCK:
1009       {
1010         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_10x6_KHR.
1011         Assign(GL_COMPRESSED_RGBA_ASTC_10x6_KHR, 0);
1012         break;
1013       }
1014       case Graphics::Format::ASTC_10x6_SRGB_BLOCK:
1015       {
1016         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR.
1017         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR, 0);
1018         break;
1019       }
1020       case Graphics::Format::ASTC_10x8_UNORM_BLOCK:
1021       {
1022         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_10x8_KHR.
1023         Assign(GL_COMPRESSED_RGBA_ASTC_10x8_KHR, 0);
1024         break;
1025       }
1026       case Graphics::Format::ASTC_10x8_SRGB_BLOCK:
1027       {
1028         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR.
1029         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR, 0);
1030         break;
1031       }
1032       case Graphics::Format::ASTC_10x10_UNORM_BLOCK:
1033       {
1034         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_10x10_KHR.
1035         Assign(GL_COMPRESSED_RGBA_ASTC_10x10_KHR, 0);
1036         break;
1037       }
1038       case Graphics::Format::ASTC_10x10_SRGB_BLOCK:
1039       {
1040         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR.
1041         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR, 0);
1042         break;
1043       }
1044       case Graphics::Format::ASTC_12x10_UNORM_BLOCK:
1045       {
1046         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_12x10_KHR.
1047         Assign(GL_COMPRESSED_RGBA_ASTC_12x10_KHR, 0);
1048         break;
1049       }
1050       case Graphics::Format::ASTC_12x10_SRGB_BLOCK:
1051       {
1052         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR.
1053         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR, 0);
1054         break;
1055       }
1056       case Graphics::Format::ASTC_12x12_UNORM_BLOCK:
1057       {
1058         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_12x12_KHR.
1059         Assign(GL_COMPRESSED_RGBA_ASTC_12x12_KHR, 0);
1060         break;
1061       }
1062       case Graphics::Format::ASTC_12x12_SRGB_BLOCK:
1063       {
1064         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR.
1065         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR, 0);
1066         break;
1067       }
1068       case Graphics::Format::PVRTC1_2BPP_UNORM_BLOCK_IMG:
1069       {
1070         Assign(0, 0);
1071         break;
1072       }
1073       case Graphics::Format::PVRTC1_4BPP_UNORM_BLOCK_IMG:
1074       {
1075         ///! Using non-standard GLES 2.0 extension compressed pixel format COMPRESSED_RGB_PVRTC_4BPPV1.
1076         Assign(0x8C00, 0); ///! < Hardcoded so we can test before we move to GLES 3.0 or greater.
1077
1078         break;
1079       }
1080       case Graphics::Format::PVRTC2_2BPP_UNORM_BLOCK_IMG:
1081       {
1082         Assign(0, 0);
1083         break;
1084       }
1085       case Graphics::Format::PVRTC2_4BPP_UNORM_BLOCK_IMG:
1086       {
1087         Assign(0, 0);
1088         break;
1089       }
1090       case Graphics::Format::PVRTC1_2BPP_SRGB_BLOCK_IMG:
1091       {
1092         Assign(0, 0);
1093         break;
1094       }
1095       case Graphics::Format::PVRTC1_4BPP_SRGB_BLOCK_IMG:
1096       {
1097         Assign(0, 0);
1098         break;
1099       }
1100       case Graphics::Format::PVRTC2_2BPP_SRGB_BLOCK_IMG:
1101       {
1102         Assign(0, 0);
1103         break;
1104       }
1105       case Graphics::Format::PVRTC2_4BPP_SRGB_BLOCK_IMG:
1106       {
1107         Assign(0, 0);
1108         break;
1109       }
1110     }
1111   }
1112
1113   constexpr inline void Assign(uint32_t f, uint32_t t)
1114   {
1115     format         = f;
1116     internalFormat = f;
1117     type           = t;
1118   }
1119   constexpr inline void AssignInternal(uint32_t f, uint32_t i, uint32_t t)
1120   {
1121     format         = f;
1122     internalFormat = i;
1123     type           = t;
1124   }
1125
1126   uint32_t format{0};
1127   uint32_t internalFormat{0};
1128   uint32_t type{0};
1129 };
1130
1131 struct FormatCompression
1132 {
1133   /**
1134    * Constuctor from Graphics::Format
1135    * @param value
1136    */
1137   constexpr explicit FormatCompression(Graphics::Format value)
1138   {
1139     switch(value)
1140     {
1141       case Graphics::Format::ETC2_R8G8B8_UNORM_BLOCK:
1142       case Graphics::Format::ETC2_R8G8B8_SRGB_BLOCK:
1143       case Graphics::Format::ETC2_R8G8B8A1_UNORM_BLOCK:
1144       case Graphics::Format::ETC2_R8G8B8A1_SRGB_BLOCK:
1145       case Graphics::Format::ETC2_R8G8B8A8_UNORM_BLOCK:
1146       case Graphics::Format::ETC2_R8G8B8A8_SRGB_BLOCK:
1147       case Graphics::Format::EAC_R11_UNORM_BLOCK:
1148       case Graphics::Format::EAC_R11_SNORM_BLOCK:
1149       case Graphics::Format::EAC_R11G11_UNORM_BLOCK:
1150       case Graphics::Format::EAC_R11G11_SNORM_BLOCK:
1151       case Graphics::Format::ASTC_4x4_UNORM_BLOCK:
1152       case Graphics::Format::ASTC_4x4_SRGB_BLOCK:
1153       case Graphics::Format::ASTC_5x4_UNORM_BLOCK:
1154       case Graphics::Format::ASTC_5x4_SRGB_BLOCK:
1155       case Graphics::Format::ASTC_5x5_UNORM_BLOCK:
1156       case Graphics::Format::ASTC_5x5_SRGB_BLOCK:
1157       case Graphics::Format::ASTC_6x5_UNORM_BLOCK:
1158       case Graphics::Format::ASTC_6x5_SRGB_BLOCK:
1159       case Graphics::Format::ASTC_6x6_UNORM_BLOCK:
1160       case Graphics::Format::ASTC_6x6_SRGB_BLOCK:
1161       case Graphics::Format::ASTC_8x5_UNORM_BLOCK:
1162       case Graphics::Format::ASTC_8x5_SRGB_BLOCK:
1163       case Graphics::Format::ASTC_8x6_UNORM_BLOCK:
1164       case Graphics::Format::ASTC_8x6_SRGB_BLOCK:
1165       case Graphics::Format::ASTC_8x8_UNORM_BLOCK:
1166       case Graphics::Format::ASTC_8x8_SRGB_BLOCK:
1167       case Graphics::Format::ASTC_10x5_UNORM_BLOCK:
1168       case Graphics::Format::ASTC_10x5_SRGB_BLOCK:
1169       case Graphics::Format::ASTC_10x6_UNORM_BLOCK:
1170       case Graphics::Format::ASTC_10x6_SRGB_BLOCK:
1171       case Graphics::Format::ASTC_10x8_UNORM_BLOCK:
1172       case Graphics::Format::ASTC_10x8_SRGB_BLOCK:
1173       case Graphics::Format::ASTC_10x10_UNORM_BLOCK:
1174       case Graphics::Format::ASTC_10x10_SRGB_BLOCK:
1175       case Graphics::Format::ASTC_12x10_UNORM_BLOCK:
1176       case Graphics::Format::ASTC_12x10_SRGB_BLOCK:
1177       case Graphics::Format::ASTC_12x12_UNORM_BLOCK:
1178       case Graphics::Format::ASTC_12x12_SRGB_BLOCK:
1179       case Graphics::Format::PVRTC1_2BPP_UNORM_BLOCK_IMG:
1180       case Graphics::Format::PVRTC1_4BPP_UNORM_BLOCK_IMG:
1181       case Graphics::Format::PVRTC2_2BPP_UNORM_BLOCK_IMG:
1182       case Graphics::Format::PVRTC2_4BPP_UNORM_BLOCK_IMG:
1183       case Graphics::Format::PVRTC1_2BPP_SRGB_BLOCK_IMG:
1184       case Graphics::Format::PVRTC1_4BPP_SRGB_BLOCK_IMG:
1185       case Graphics::Format::PVRTC2_2BPP_SRGB_BLOCK_IMG:
1186       case Graphics::Format::PVRTC2_4BPP_SRGB_BLOCK_IMG:
1187         compressed = true;
1188         break;
1189       default:
1190         break;
1191     }
1192   }
1193   bool compressed{false};
1194 };
1195
1196 struct GLSamplerFilter
1197 {
1198   constexpr explicit GLSamplerFilter(Graphics::SamplerFilter filter)
1199   {
1200     switch(filter)
1201     {
1202       case Graphics::SamplerFilter::NEAREST:
1203       {
1204         glFilter = GL_NEAREST;
1205         break;
1206       }
1207       case Graphics::SamplerFilter::LINEAR:
1208       {
1209         glFilter = GL_LINEAR;
1210         break;
1211       }
1212     }
1213   }
1214   uint32_t glFilter{0};
1215 };
1216
1217 struct GLSamplerFilterAndMipMapMode
1218 {
1219   constexpr explicit GLSamplerFilterAndMipMapMode(Graphics::SamplerFilter     filter,
1220                                                   Graphics::SamplerMipmapMode mipMapMode)
1221   {
1222     switch(filter)
1223     {
1224       case Graphics::SamplerFilter::NEAREST:
1225       {
1226         switch(mipMapMode)
1227         {
1228           case Graphics::SamplerMipmapMode::NONE:
1229           {
1230             glFilter = GL_NEAREST;
1231             break;
1232           }
1233           case Graphics::SamplerMipmapMode::NEAREST:
1234           {
1235             glFilter = GL_NEAREST_MIPMAP_NEAREST;
1236             break;
1237           }
1238           case Graphics::SamplerMipmapMode::LINEAR:
1239           {
1240             glFilter = GL_NEAREST_MIPMAP_LINEAR;
1241             break;
1242           }
1243         }
1244         break;
1245       }
1246
1247       case Graphics::SamplerFilter::LINEAR:
1248       {
1249         switch(mipMapMode)
1250         {
1251           case Graphics::SamplerMipmapMode::NONE:
1252           {
1253             glFilter = GL_LINEAR;
1254             break;
1255           }
1256           case Graphics::SamplerMipmapMode::NEAREST:
1257           {
1258             glFilter = GL_LINEAR_MIPMAP_NEAREST;
1259             break;
1260           }
1261           case Graphics::SamplerMipmapMode::LINEAR:
1262           {
1263             glFilter = GL_LINEAR_MIPMAP_LINEAR;
1264             break;
1265           }
1266         }
1267         break;
1268       }
1269     }
1270   }
1271
1272   inline explicit operator uint32_t() const
1273   {
1274     return glFilter;
1275   }
1276
1277   inline operator int() const
1278   {
1279     return static_cast<int>(glFilter);
1280   }
1281
1282   uint32_t glFilter{0};
1283 };
1284
1285 /** Converts vertex format to GL */
1286 struct GLVertexFormat
1287 {
1288   constexpr explicit GLVertexFormat(Graphics::VertexInputFormat gfxFormat)
1289   {
1290     switch(gfxFormat)
1291     {
1292       case VertexInputFormat::FVECTOR2:
1293       {
1294         format = GL_FLOAT;
1295         size   = 2;
1296         break;
1297       }
1298       case VertexInputFormat::FVECTOR3:
1299       {
1300         format = GL_FLOAT;
1301         size   = 3;
1302         break;
1303       }
1304       case VertexInputFormat::FVECTOR4:
1305       {
1306         format = GL_FLOAT;
1307         size   = 4;
1308         break;
1309       }
1310       case VertexInputFormat::FLOAT:
1311       {
1312         format = GL_FLOAT;
1313         size   = 1;
1314         break;
1315       }
1316       case VertexInputFormat::INTEGER:
1317       {
1318         format = GL_INT;
1319         size   = 1;
1320         break;
1321       }
1322       case VertexInputFormat::IVECTOR2:
1323       {
1324         format = GL_INT;
1325         size   = 2;
1326         break;
1327       }
1328       case VertexInputFormat::IVECTOR3:
1329       {
1330         format = GL_INT;
1331         size   = 3;
1332         break;
1333       }
1334       case VertexInputFormat::IVECTOR4:
1335       {
1336         format = GL_INT;
1337         size   = 4;
1338         break;
1339       }
1340       case VertexInputFormat::UNDEFINED:
1341       {
1342         format = 0;
1343         size   = 0;
1344         break;
1345       }
1346     }
1347   }
1348
1349   GLenum   format{0u};
1350   uint32_t size{0u};
1351 };
1352
1353 struct GLTextureTarget
1354 {
1355   constexpr explicit GLTextureTarget(Graphics::TextureType graphicsTextureType)
1356   {
1357     switch(graphicsTextureType)
1358     {
1359       case Graphics::TextureType::TEXTURE_2D:
1360       {
1361         target = GL_TEXTURE_2D;
1362         break;
1363       }
1364       case Graphics::TextureType::TEXTURE_3D:
1365       {
1366         target = GL_TEXTURE_3D;
1367         break;
1368       }
1369       case Graphics::TextureType::TEXTURE_CUBEMAP:
1370       {
1371         target = GL_TEXTURE_CUBE_MAP;
1372         break;
1373       }
1374     }
1375   }
1376   GLenum target{GL_TEXTURE_2D};
1377 };
1378
1379 struct GLAddressMode
1380 {
1381   constexpr explicit GLAddressMode(Graphics::SamplerAddressMode graphicsAddressMode)
1382   {
1383     switch(graphicsAddressMode)
1384     {
1385       case Graphics::SamplerAddressMode::REPEAT:
1386       {
1387         texParameter = GL_REPEAT;
1388         break;
1389       }
1390       case Graphics::SamplerAddressMode::MIRRORED_REPEAT:
1391       {
1392         texParameter = GL_MIRRORED_REPEAT;
1393         break;
1394       }
1395       case Graphics::SamplerAddressMode::CLAMP_TO_EDGE:
1396       {
1397         texParameter = GL_CLAMP_TO_EDGE;
1398         break;
1399       }
1400       case Graphics::SamplerAddressMode::CLAMP_TO_BORDER:
1401       {
1402         texParameter = GL_CLAMP_TO_EDGE;
1403         break;
1404       }
1405       case Graphics::SamplerAddressMode::MIRROR_CLAMP_TO_EDGE:
1406       {
1407         texParameter = GL_CLAMP_TO_EDGE;
1408         break;
1409       }
1410     }
1411   }
1412   GLenum texParameter{GL_CLAMP_TO_EDGE};
1413 };
1414
1415 struct GLCompareOp
1416 {
1417   constexpr explicit GLCompareOp(Graphics::CompareOp compareOp)
1418   {
1419     switch(compareOp)
1420     {
1421       case Graphics::CompareOp::NEVER:
1422         op = GL_NEVER;
1423         break;
1424       case Graphics::CompareOp::LESS:
1425         op = GL_LESS;
1426         break;
1427       case Graphics::CompareOp::EQUAL:
1428         op = GL_EQUAL;
1429         break;
1430       case Graphics::CompareOp::LESS_OR_EQUAL:
1431         op = GL_LEQUAL;
1432         break;
1433       case Graphics::CompareOp::GREATER:
1434         op = GL_GREATER;
1435         break;
1436       case Graphics::CompareOp::NOT_EQUAL:
1437         op = GL_NOTEQUAL;
1438         break;
1439       case Graphics::CompareOp::GREATER_OR_EQUAL:
1440         op = GL_GEQUAL;
1441         break;
1442       case Graphics::CompareOp::ALWAYS:
1443         op = GL_ALWAYS;
1444         break;
1445     }
1446   }
1447   GLenum op{GL_LESS};
1448 };
1449
1450 struct GLStencilOp
1451 {
1452   constexpr explicit GLStencilOp(Graphics::StencilOp stencilOp)
1453   {
1454     switch(stencilOp)
1455     {
1456       case Graphics::StencilOp::KEEP:
1457         op = GL_KEEP;
1458         break;
1459       case Graphics::StencilOp::ZERO:
1460         op = GL_ZERO;
1461         break;
1462       case Graphics::StencilOp::REPLACE:
1463         op = GL_REPLACE;
1464         break;
1465       case Graphics::StencilOp::INCREMENT_AND_CLAMP:
1466         op = GL_INCR;
1467         break;
1468       case Graphics::StencilOp::DECREMENT_AND_CLAMP:
1469         op = GL_DECR;
1470         break;
1471       case Graphics::StencilOp::INVERT:
1472         op = GL_INVERT;
1473         break;
1474       case Graphics::StencilOp::INCREMENT_AND_WRAP:
1475         op = GL_INCR_WRAP;
1476         break;
1477       case Graphics::StencilOp::DECREMENT_AND_WRAP:
1478         op = GL_DECR_WRAP;
1479         break;
1480     }
1481   }
1482   GLenum op{GL_KEEP};
1483 };
1484
1485 /**
1486  * @brief Descriptor of single buffer binding within
1487  * command buffer.
1488  */
1489 struct VertexBufferBindingDescriptor
1490 {
1491   const GLES::Buffer* buffer{nullptr};
1492   uint32_t            offset{0u};
1493 };
1494
1495 /**
1496  * @brief Descriptor of ix buffer binding within
1497  * command buffer.
1498  */
1499 struct IndexBufferBindingDescriptor
1500 {
1501   const GLES::Buffer* buffer{nullptr};
1502   uint32_t            offset{};
1503   Graphics::Format    format{};
1504 };
1505
1506 /**
1507  * @brief Descriptor of uniform buffer binding within
1508  * command buffer.
1509  */
1510 struct UniformBufferBindingDescriptor
1511 {
1512   const GLES::Buffer* buffer{nullptr};
1513   uint32_t            binding{0u};
1514   uint32_t            offset{0u};
1515   bool                emulated; ///<true if UBO is emulated for old gfx API
1516 };
1517
1518 /**
1519  * @brief The descriptor of draw call
1520  */
1521 struct DrawCallDescriptor
1522 {
1523   /**
1524    * @brief Enum specifying type of the draw call
1525    */
1526   enum class Type
1527   {
1528     DRAW,
1529     DRAW_INDEXED,
1530     DRAW_INDEXED_INDIRECT
1531   };
1532
1533   Type type{}; ///< Type of the draw call
1534
1535   /**
1536    * Union contains data for all types of draw calls.
1537    */
1538   union
1539   {
1540     /**
1541      * @brief Vertex array draw
1542      */
1543     struct
1544     {
1545       uint32_t vertexCount;
1546       uint32_t instanceCount;
1547       uint32_t firstVertex;
1548       uint32_t firstInstance;
1549     } draw;
1550
1551     /**
1552      * @brief Indexed draw
1553      */
1554     struct
1555     {
1556       uint32_t indexCount;
1557       uint32_t instanceCount;
1558       uint32_t firstIndex;
1559       int32_t  vertexOffset;
1560       uint32_t firstInstance;
1561     } drawIndexed;
1562
1563     /**
1564      * @brief Indexed draw indirect
1565      */
1566     struct
1567     {
1568       const GLES::Buffer* buffer;
1569       uint32_t            offset;
1570       uint32_t            drawCount;
1571       uint32_t            stride;
1572     } drawIndexedIndirect;
1573   };
1574 };
1575
1576 /**
1577  * @brief Topologu conversion from Graphics to GLES
1578  */
1579 struct GLESTopology
1580 {
1581   explicit constexpr GLESTopology(PrimitiveTopology topology)
1582   {
1583     switch(topology)
1584     {
1585       case PrimitiveTopology::POINT_LIST:
1586       {
1587         primitiveTopology = GL_POINTS;
1588         break;
1589       }
1590       case PrimitiveTopology::LINE_LIST:
1591       {
1592         primitiveTopology = GL_LINES;
1593         break;
1594       }
1595       case PrimitiveTopology::LINE_LOOP:
1596       {
1597         primitiveTopology = GL_LINE_LOOP;
1598         break;
1599       }
1600       case PrimitiveTopology::LINE_STRIP:
1601       {
1602         primitiveTopology = GL_LINE_STRIP;
1603         break;
1604       }
1605       case PrimitiveTopology::TRIANGLE_LIST:
1606       {
1607         primitiveTopology = GL_TRIANGLES;
1608         break;
1609       }
1610       case PrimitiveTopology::TRIANGLE_STRIP:
1611       {
1612         primitiveTopology = GL_TRIANGLE_STRIP;
1613         break;
1614       }
1615       case PrimitiveTopology::TRIANGLE_FAN:
1616       {
1617         primitiveTopology = GL_TRIANGLE_FAN;
1618         break;
1619       }
1620     }
1621   }
1622
1623   /**
1624    * @brief Explicit type conversion operator
1625    * @return converted value
1626    */
1627   constexpr inline operator GLenum() const
1628   {
1629     return primitiveTopology;
1630   }
1631
1632   GLenum primitiveTopology{0}; ///< Topology
1633 };
1634
1635 /**
1636  * @brief Index format conversion structure
1637  */
1638 struct GLIndexFormat
1639 {
1640   explicit constexpr GLIndexFormat(Format _format)
1641   {
1642     switch(_format)
1643     {
1644       // TODO: add more formats
1645       case Format::R16_UINT:
1646       {
1647         format = GL_UNSIGNED_SHORT;
1648         break;
1649       }
1650       default:
1651       {
1652         format = 0;
1653       }
1654     }
1655   }
1656
1657   /**
1658    * @brief Explicit type conversion operator
1659    * @return converted value
1660    */
1661   constexpr inline operator GLenum() const
1662   {
1663     return format;
1664   }
1665
1666   GLenum format{0}; ///< Converted format
1667 };
1668
1669 /**
1670  * @brief Conversion of blending function factor
1671  */
1672 struct GLBlendFunc
1673 {
1674   constexpr explicit GLBlendFunc(Graphics::BlendFactor factor)
1675   {
1676     switch(factor)
1677     {
1678       case Graphics::BlendFactor::ZERO:
1679       {
1680         glFactor = GL_ZERO;
1681         break;
1682       }
1683       case Graphics::BlendFactor::ONE:
1684       {
1685         glFactor = GL_ONE;
1686         break;
1687       }
1688       case Graphics::BlendFactor::SRC_COLOR:
1689       {
1690         glFactor = GL_SRC_COLOR;
1691         break;
1692       }
1693       case Graphics::BlendFactor::ONE_MINUS_SRC_COLOR:
1694       {
1695         glFactor = GL_ONE_MINUS_SRC_COLOR;
1696         break;
1697       }
1698       case Graphics::BlendFactor::DST_COLOR:
1699       {
1700         glFactor = GL_DST_COLOR;
1701         break;
1702       }
1703       case Graphics::BlendFactor::ONE_MINUS_DST_COLOR:
1704       {
1705         glFactor = GL_ONE_MINUS_DST_COLOR;
1706         break;
1707       }
1708       case Graphics::BlendFactor::SRC_ALPHA:
1709       {
1710         glFactor = GL_SRC_ALPHA;
1711         break;
1712       }
1713       case Graphics::BlendFactor::ONE_MINUS_SRC_ALPHA:
1714       {
1715         glFactor = GL_ONE_MINUS_SRC_ALPHA;
1716         break;
1717       }
1718       case Graphics::BlendFactor::DST_ALPHA:
1719       {
1720         glFactor = GL_DST_ALPHA;
1721         break;
1722       }
1723       case Graphics::BlendFactor::ONE_MINUS_DST_ALPHA:
1724       {
1725         glFactor = GL_ONE_MINUS_DST_ALPHA;
1726         break;
1727       }
1728       case Graphics::BlendFactor::CONSTANT_COLOR:
1729       {
1730         glFactor = GL_CONSTANT_COLOR;
1731         break;
1732       }
1733       case Graphics::BlendFactor::ONE_MINUS_CONSTANT_COLOR:
1734       {
1735         glFactor = GL_ONE_MINUS_CONSTANT_COLOR;
1736         break;
1737       }
1738       case Graphics::BlendFactor::CONSTANT_ALPHA:
1739       {
1740         glFactor = GL_CONSTANT_ALPHA;
1741         break;
1742       }
1743       case Graphics::BlendFactor::ONE_MINUS_CONSTANT_ALPHA:
1744       {
1745         glFactor = GL_ONE_MINUS_CONSTANT_ALPHA;
1746         break;
1747       }
1748       case Graphics::BlendFactor::SRC_ALPHA_SATURATE:
1749       {
1750         glFactor = GL_SRC_ALPHA_SATURATE;
1751         break;
1752       }
1753       // Below may be unsupported without extension
1754       case Graphics::BlendFactor::SRC1_COLOR:
1755       {
1756         glFactor = 0u;
1757         break;
1758       }
1759       case Graphics::BlendFactor::ONE_MINUS_SRC1_COLOR:
1760       {
1761         glFactor = 0u;
1762         break;
1763       }
1764       case Graphics::BlendFactor::SRC1_ALPHA:
1765       {
1766         glFactor = 0u;
1767         break;
1768       }
1769       case Graphics::BlendFactor::ONE_MINUS_SRC1_ALPHA:
1770       {
1771         glFactor = 0u;
1772         break;
1773       }
1774     }
1775   }
1776
1777   /**
1778    * @brief Explicit type conversion operator
1779    * @return converted value
1780    */
1781   constexpr inline operator GLenum() const
1782   {
1783     return glFactor;
1784   }
1785
1786   GLenum glFactor{0u};
1787 };
1788
1789 /**
1790  * @brief Converts Blend Op to GL
1791  */
1792 struct GLBlendOp
1793 {
1794   constexpr explicit GLBlendOp(Graphics::BlendOp blendOp)
1795   {
1796     switch(blendOp)
1797     {
1798       case Graphics::BlendOp::ADD:
1799       {
1800         glBlendOp = GL_FUNC_ADD;
1801         break;
1802       }
1803       case Graphics::BlendOp::SUBTRACT:
1804       {
1805         glBlendOp = GL_FUNC_SUBTRACT;
1806         break;
1807       }
1808       case Graphics::BlendOp::REVERSE_SUBTRACT:
1809       {
1810         glBlendOp = GL_FUNC_REVERSE_SUBTRACT;
1811         break;
1812       }
1813       case Graphics::BlendOp::MIN:
1814       {
1815         glBlendOp = GL_MIN;
1816         break;
1817       }
1818       case Graphics::BlendOp::MAX:
1819       {
1820         glBlendOp = GL_MAX;
1821         break;
1822       }
1823       case Graphics::BlendOp::MULTIPLY:
1824       {
1825         glBlendOp = GL_MULTIPLY;
1826         break;
1827       }
1828       case Graphics::BlendOp::SCREEN:
1829       {
1830         glBlendOp = GL_SCREEN;
1831         break;
1832       }
1833       case Graphics::BlendOp::OVERLAY:
1834       {
1835         glBlendOp = GL_OVERLAY;
1836         break;
1837       }
1838       case Graphics::BlendOp::DARKEN:
1839       {
1840         glBlendOp = GL_DARKEN;
1841         break;
1842       }
1843       case Graphics::BlendOp::LIGHTEN:
1844       {
1845         glBlendOp = GL_LIGHTEN;
1846         break;
1847       }
1848       case Graphics::BlendOp::COLOR_DODGE:
1849       {
1850         glBlendOp = GL_COLORDODGE;
1851         break;
1852       }
1853       case Graphics::BlendOp::COLOR_BURN:
1854       {
1855         glBlendOp = GL_COLORBURN;
1856         break;
1857       }
1858       case Graphics::BlendOp::HARD_LIGHT:
1859       {
1860         glBlendOp = GL_HARDLIGHT;
1861         break;
1862       }
1863       case Graphics::BlendOp::SOFT_LIGHT:
1864       {
1865         glBlendOp = GL_SOFTLIGHT;
1866         break;
1867       }
1868       case Graphics::BlendOp::DIFFERENCE:
1869       {
1870         glBlendOp = GL_DIFFERENCE;
1871         break;
1872       }
1873       case Graphics::BlendOp::EXCLUSION:
1874       {
1875         glBlendOp = GL_EXCLUSION;
1876         break;
1877       }
1878       case Graphics::BlendOp::HUE:
1879       {
1880         glBlendOp = GL_HSL_HUE;
1881         break;
1882       }
1883       case Graphics::BlendOp::SATURATION:
1884       {
1885         glBlendOp = GL_HSL_SATURATION;
1886         break;
1887       }
1888       case Graphics::BlendOp::COLOR:
1889       {
1890         glBlendOp = GL_HSL_COLOR;
1891         break;
1892       }
1893       case Graphics::BlendOp::LUMINOSITY:
1894       {
1895         glBlendOp = GL_HSL_LUMINOSITY;
1896         break;
1897       }
1898     }
1899   }
1900
1901   /**
1902    * @brief Explicit type conversion operator
1903    * @return converted value
1904    */
1905   constexpr inline operator GLenum() const
1906   {
1907     return glBlendOp;
1908   }
1909
1910   GLenum glBlendOp{0u};
1911 };
1912
1913 /**
1914  * @brief Converts GL cull mode
1915  */
1916 struct GLCullMode
1917 {
1918   constexpr explicit GLCullMode(Graphics::CullMode cullMode)
1919   {
1920     switch(cullMode)
1921     {
1922       case Graphics::CullMode::NONE: // this isn't really accepted by GL!
1923       {
1924         glCullMode = GL_NONE;
1925         break;
1926       }
1927       case Graphics::CullMode::FRONT:
1928       {
1929         glCullMode = GL_FRONT;
1930         break;
1931       }
1932       case Graphics::CullMode::BACK:
1933       {
1934         glCullMode = GL_BACK;
1935         break;
1936       }
1937       case Graphics::CullMode::FRONT_AND_BACK:
1938       {
1939         glCullMode = GL_FRONT_AND_BACK;
1940         break;
1941       }
1942     }
1943   }
1944
1945   /**
1946    * @brief Explicit type conversion operator
1947    * @return converted value
1948    */
1949   constexpr inline operator GLenum() const
1950   {
1951     return glCullMode;
1952   }
1953
1954   GLenum glCullMode{0u};
1955 };
1956
1957 /**
1958  * @brief enum with GL types
1959  */
1960 enum class GLType
1961 {
1962   UNDEFINED      = 0x0,
1963   FLOAT_VEC2     = 0x8B50,
1964   FLOAT_VEC3     = 0x8B51,
1965   FLOAT_VEC4     = 0x8B52,
1966   INT_VEC2       = 0x8B53,
1967   INT_VEC3       = 0x8B54,
1968   INT_VEC4       = 0x8B55,
1969   BOOL           = 0x8B56,
1970   BOOL_VEC2      = 0x8B57,
1971   BOOL_VEC3      = 0x8B58,
1972   BOOL_VEC4      = 0x8B59,
1973   FLOAT_MAT2     = 0x8B5A,
1974   FLOAT_MAT3     = 0x8B5B,
1975   FLOAT_MAT4     = 0x8B5C,
1976   SAMPLER_2D     = 0x8B5E,
1977   SAMPLER_CUBE   = 0x8B60,
1978   BYTE           = 0x1400,
1979   UNSIGNED_BYTE  = 0x1401,
1980   SHORT          = 0x1402,
1981   UNSIGNED_SHORT = 0x1403,
1982   INT            = 0x1404,
1983   UNSIGNED_INT   = 0x1405,
1984   FLOAT          = 0x1406,
1985   FIXED          = 0x140C,
1986 };
1987
1988 /**
1989  * @brief GL type conversion (used with reflection)
1990  */
1991 struct GLTypeConversion
1992 {
1993   constexpr explicit GLTypeConversion(GLenum value)
1994   {
1995     switch(value)
1996     {
1997       case GL_FLOAT_VEC2:
1998       {
1999         type = GLType::FLOAT_VEC2;
2000         break;
2001       }
2002       case GL_FLOAT_VEC3:
2003       {
2004         type = GLType::FLOAT_VEC3;
2005         break;
2006       }
2007       case GL_FLOAT_VEC4:
2008       {
2009         type = GLType::FLOAT_VEC4;
2010         break;
2011       }
2012       case GL_INT_VEC2:
2013       {
2014         type = GLType::INT_VEC2;
2015         break;
2016       }
2017       case GL_INT_VEC3:
2018       {
2019         type = GLType::INT_VEC3;
2020         break;
2021       }
2022       case GL_INT_VEC4:
2023       {
2024         type = GLType::INT_VEC4;
2025         break;
2026       }
2027       case GL_BOOL:
2028       {
2029         type = GLType::BOOL;
2030         break;
2031       }
2032       case GL_BOOL_VEC2:
2033       {
2034         type = GLType::BOOL_VEC2;
2035         break;
2036       }
2037       case GL_BOOL_VEC3:
2038       {
2039         type = GLType::BOOL_VEC3;
2040         break;
2041       }
2042       case GL_BOOL_VEC4:
2043       {
2044         type = GLType::BOOL_VEC4;
2045         break;
2046       }
2047       case GL_FLOAT_MAT2:
2048       {
2049         type = GLType::FLOAT_MAT2;
2050         break;
2051       }
2052       case GL_FLOAT_MAT3:
2053       {
2054         type = GLType::FLOAT_MAT3;
2055         break;
2056       }
2057       case GL_FLOAT_MAT4:
2058       {
2059         type = GLType::FLOAT_MAT4;
2060         break;
2061       }
2062       case GL_SAMPLER_2D:
2063       {
2064         type = GLType::SAMPLER_2D;
2065         break;
2066       }
2067       case GL_SAMPLER_CUBE:
2068       {
2069         type = GLType::SAMPLER_CUBE;
2070         break;
2071       }
2072       case GL_FLOAT:
2073       {
2074         type = GLType::FLOAT;
2075         break;
2076       }
2077       default:
2078       {
2079         type = GLType::UNDEFINED;
2080       }
2081     }
2082   }
2083
2084   GLType type{GLType::UNDEFINED};
2085 };
2086
2087 enum class GLESVersion
2088 {
2089   GLES_20 = 20,
2090   GLES_30 = 30,
2091   GLES_31 = 31,
2092   GLES_32 = 32
2093 };
2094
2095 /**
2096  * @brief Types of bond texture cached in the context
2097  */
2098 enum class BoundTextureType
2099 {
2100   TEXTURE_2D,
2101   TEXTURE_3D,
2102   TEXTURE_CUBEMAP,
2103   TEXTURE_EXTERNAL_OES
2104 };
2105
2106 /**
2107  * This class stores indirect pointer, used by the CommandBuffer
2108  * to store data allocated within resizeable pool
2109  */
2110 template<class T>
2111 struct IndirectPtr
2112 {
2113   uint32_t ptr;  // relative pointer
2114   void**   base; // base pointer
2115
2116   inline T* operator->()
2117   {
2118     return reinterpret_cast<T*>((reinterpret_cast<uint8_t*>(*base) + ptr));
2119   }
2120
2121   inline T& operator*()
2122   {
2123     return *reinterpret_cast<T*>((reinterpret_cast<uint8_t*>(*base) + ptr));
2124   }
2125
2126   // Returns indirect pointer casted to requested type
2127   T* Ptr() const
2128   {
2129     auto val = reinterpret_cast<T*>((reinterpret_cast<uint8_t*>(*base) + ptr));
2130     return val;
2131   }
2132
2133   inline T& operator[](int index)
2134   {
2135     return reinterpret_cast<T*>((reinterpret_cast<uint8_t*>(*base) + ptr))[index];
2136   }
2137
2138   // Fake assignment operator for void* type
2139   inline IndirectPtr<T>& operator=(void* p)
2140   {
2141     ptr  = 0;
2142     base = nullptr;
2143     return *this;
2144   }
2145 };
2146
2147 /**
2148  * The descriptor of BeginRenderPass command
2149  */
2150 struct BeginRenderPassDescriptor
2151 {
2152   const GLES::RenderPass*   renderPass;
2153   const GLES::RenderTarget* renderTarget;
2154   Rect2D                    renderArea;
2155   IndirectPtr<ClearValue>   clearValues;
2156   uint32_t                  clearValuesCount;
2157 };
2158
2159 } // namespace Dali::Graphics::GLES
2160
2161 #endif //DALI_GRAPHICS_API_TYPES_H