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(0, 0);
 869         break;
 870       }
 871       case Graphics::Format::ETC2_R8G8B8A8_SRGB_BLOCK:
 872       {
 873         Assign(0, 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 GLSamplerFilter
1132 {
1133   constexpr explicit GLSamplerFilter(Graphics::SamplerFilter filter)
1134   {
1135     switch(filter)
1136     {
1137       case Graphics::SamplerFilter::NEAREST:
1138       {
1139         glFilter = GL_NEAREST;
1140         break;
1141       }
1142       case Graphics::SamplerFilter::LINEAR:
1143       {
1144         glFilter = GL_LINEAR;
1145         break;
1146       }
1147     }
1148   }
1149   uint32_t glFilter{0};
1150 };
1151
1152 struct GLSamplerFilterAndMipMapMode
1153 {
1154   constexpr explicit GLSamplerFilterAndMipMapMode(Graphics::SamplerFilter     filter,
1155                                                   Graphics::SamplerMipmapMode mipMapMode)
1156   {
1157     switch(filter)
1158     {
1159       case Graphics::SamplerFilter::NEAREST:
1160       {
1161         switch(mipMapMode)
1162         {
1163           case Graphics::SamplerMipmapMode::NONE:
1164           {
1165             glFilter = GL_NEAREST;
1166             break;
1167           }
1168           case Graphics::SamplerMipmapMode::NEAREST:
1169           {
1170             glFilter = GL_NEAREST_MIPMAP_NEAREST;
1171             break;
1172           }
1173           case Graphics::SamplerMipmapMode::LINEAR:
1174           {
1175             glFilter = GL_NEAREST_MIPMAP_LINEAR;
1176             break;
1177           }
1178         }
1179         break;
1180       }
1181
1182       case Graphics::SamplerFilter::LINEAR:
1183       {
1184         switch(mipMapMode)
1185         {
1186           case Graphics::SamplerMipmapMode::NONE:
1187           {
1188             glFilter = GL_LINEAR;
1189             break;
1190           }
1191           case Graphics::SamplerMipmapMode::NEAREST:
1192           {
1193             glFilter = GL_LINEAR_MIPMAP_NEAREST;
1194             break;
1195           }
1196           case Graphics::SamplerMipmapMode::LINEAR:
1197           {
1198             glFilter = GL_LINEAR_MIPMAP_LINEAR;
1199             break;
1200           }
1201         }
1202         break;
1203       }
1204     }
1205   }
1206
1207   inline explicit operator uint32_t() const
1208   {
1209     return glFilter;
1210   }
1211
1212   inline operator int() const
1213   {
1214     return static_cast<int>(glFilter);
1215   }
1216
1217   uint32_t glFilter{0};
1218 };
1219
1220 /** Converts vertex format to GL */
1221 struct GLVertexFormat
1222 {
1223   constexpr explicit GLVertexFormat(Graphics::VertexInputFormat gfxFormat)
1224   {
1225     switch(gfxFormat)
1226     {
1227       case VertexInputFormat::FVECTOR2:
1228       {
1229         format = GL_FLOAT;
1230         size   = 2;
1231         break;
1232       }
1233       case VertexInputFormat::FVECTOR3:
1234       {
1235         format = GL_FLOAT;
1236         size   = 3;
1237         break;
1238       }
1239       case VertexInputFormat::FVECTOR4:
1240       {
1241         format = GL_FLOAT;
1242         size   = 4;
1243         break;
1244       }
1245       case VertexInputFormat::FLOAT:
1246       {
1247         format = GL_FLOAT;
1248         size   = 1;
1249         break;
1250       }
1251       case VertexInputFormat::INTEGER:
1252       {
1253         format = GL_INT;
1254         size   = 1;
1255         break;
1256       }
1257       case VertexInputFormat::IVECTOR2:
1258       {
1259         format = GL_INT;
1260         size   = 2;
1261         break;
1262       }
1263       case VertexInputFormat::IVECTOR3:
1264       {
1265         format = GL_INT;
1266         size   = 3;
1267         break;
1268       }
1269       case VertexInputFormat::IVECTOR4:
1270       {
1271         format = GL_INT;
1272         size   = 4;
1273         break;
1274       }
1275       case VertexInputFormat::UNDEFINED:
1276       {
1277         format = 0;
1278         size   = 0;
1279         break;
1280       }
1281     }
1282   }
1283
1284   GLenum   format{0u};
1285   uint32_t size{0u};
1286 };
1287
1288 struct GLTextureTarget
1289 {
1290   constexpr explicit GLTextureTarget(Graphics::TextureType graphicsTextureType)
1291   {
1292     switch(graphicsTextureType)
1293     {
1294       case Graphics::TextureType::TEXTURE_2D:
1295       {
1296         target = GL_TEXTURE_2D;
1297         break;
1298       }
1299       case Graphics::TextureType::TEXTURE_3D:
1300       {
1301         target = GL_TEXTURE_3D;
1302         break;
1303       }
1304       case Graphics::TextureType::TEXTURE_CUBEMAP:
1305       {
1306         target = GL_TEXTURE_CUBE_MAP;
1307         break;
1308       }
1309     }
1310   }
1311   GLenum target{GL_TEXTURE_2D};
1312 };
1313
1314 struct GLAddressMode
1315 {
1316   constexpr explicit GLAddressMode(Graphics::SamplerAddressMode graphicsAddressMode)
1317   {
1318     switch(graphicsAddressMode)
1319     {
1320       case Graphics::SamplerAddressMode::REPEAT:
1321       {
1322         texParameter = GL_REPEAT;
1323         break;
1324       }
1325       case Graphics::SamplerAddressMode::MIRRORED_REPEAT:
1326       {
1327         texParameter = GL_MIRRORED_REPEAT;
1328         break;
1329       }
1330       case Graphics::SamplerAddressMode::CLAMP_TO_EDGE:
1331       {
1332         texParameter = GL_CLAMP_TO_EDGE;
1333         break;
1334       }
1335       case Graphics::SamplerAddressMode::CLAMP_TO_BORDER:
1336       {
1337         texParameter = GL_CLAMP_TO_EDGE;
1338         break;
1339       }
1340       case Graphics::SamplerAddressMode::MIRROR_CLAMP_TO_EDGE:
1341       {
1342         texParameter = GL_CLAMP_TO_EDGE;
1343         break;
1344       }
1345     }
1346   }
1347   GLenum texParameter{GL_CLAMP_TO_EDGE};
1348 };
1349
1350 struct GLCompareOp
1351 {
1352   constexpr explicit GLCompareOp(Graphics::CompareOp compareOp)
1353   {
1354     switch(compareOp)
1355     {
1356       case Graphics::CompareOp::NEVER:
1357         op = GL_NEVER;
1358         break;
1359       case Graphics::CompareOp::LESS:
1360         op = GL_LESS;
1361         break;
1362       case Graphics::CompareOp::EQUAL:
1363         op = GL_EQUAL;
1364         break;
1365       case Graphics::CompareOp::LESS_OR_EQUAL:
1366         op = GL_LEQUAL;
1367         break;
1368       case Graphics::CompareOp::GREATER:
1369         op = GL_GREATER;
1370         break;
1371       case Graphics::CompareOp::NOT_EQUAL:
1372         op = GL_NOTEQUAL;
1373         break;
1374       case Graphics::CompareOp::GREATER_OR_EQUAL:
1375         op = GL_GEQUAL;
1376         break;
1377       case Graphics::CompareOp::ALWAYS:
1378         op = GL_ALWAYS;
1379         break;
1380     }
1381   }
1382   GLenum op{GL_LESS};
1383 };
1384
1385 struct GLStencilOp
1386 {
1387   constexpr explicit GLStencilOp(Graphics::StencilOp stencilOp)
1388   {
1389     switch(stencilOp)
1390     {
1391       case Graphics::StencilOp::KEEP:
1392         op = GL_KEEP;
1393         break;
1394       case Graphics::StencilOp::ZERO:
1395         op = GL_ZERO;
1396         break;
1397       case Graphics::StencilOp::REPLACE:
1398         op = GL_REPLACE;
1399         break;
1400       case Graphics::StencilOp::INCREMENT_AND_CLAMP:
1401         op = GL_INCR;
1402         break;
1403       case Graphics::StencilOp::DECREMENT_AND_CLAMP:
1404         op = GL_DECR;
1405         break;
1406       case Graphics::StencilOp::INVERT:
1407         op = GL_INVERT;
1408         break;
1409       case Graphics::StencilOp::INCREMENT_AND_WRAP:
1410         op = GL_INCR_WRAP;
1411         break;
1412       case Graphics::StencilOp::DECREMENT_AND_WRAP:
1413         op = GL_DECR_WRAP;
1414         break;
1415     }
1416   }
1417   GLenum op{GL_KEEP};
1418 };
1419
1420 /**
1421  * @brief Descriptor of single buffer binding within
1422  * command buffer.
1423  */
1424 struct VertexBufferBindingDescriptor
1425 {
1426   const GLES::Buffer* buffer{nullptr};
1427   uint32_t            offset{0u};
1428 };
1429
1430 /**
1431  * @brief Descriptor of ix buffer binding within
1432  * command buffer.
1433  */
1434 struct IndexBufferBindingDescriptor
1435 {
1436   const GLES::Buffer* buffer{nullptr};
1437   uint32_t            offset{};
1438   Graphics::Format    format{};
1439 };
1440
1441 /**
1442  * @brief Descriptor of uniform buffer binding within
1443  * command buffer.
1444  */
1445 struct UniformBufferBindingDescriptor
1446 {
1447   const GLES::Buffer* buffer{nullptr};
1448   uint32_t            binding{0u};
1449   uint32_t            offset{0u};
1450   bool                emulated; ///<true if UBO is emulated for old gfx API
1451 };
1452
1453 /**
1454  * @brief The descriptor of draw call
1455  */
1456 struct DrawCallDescriptor
1457 {
1458   /**
1459    * @brief Enum specifying type of the draw call
1460    */
1461   enum class Type
1462   {
1463     DRAW,
1464     DRAW_INDEXED,
1465     DRAW_INDEXED_INDIRECT
1466   };
1467
1468   Type type{}; ///< Type of the draw call
1469
1470   /**
1471    * Union contains data for all types of draw calls.
1472    */
1473   union
1474   {
1475     /**
1476      * @brief Vertex array draw
1477      */
1478     struct
1479     {
1480       uint32_t vertexCount;
1481       uint32_t instanceCount;
1482       uint32_t firstVertex;
1483       uint32_t firstInstance;
1484     } draw;
1485
1486     /**
1487      * @brief Indexed draw
1488      */
1489     struct
1490     {
1491       uint32_t indexCount;
1492       uint32_t instanceCount;
1493       uint32_t firstIndex;
1494       int32_t  vertexOffset;
1495       uint32_t firstInstance;
1496     } drawIndexed;
1497
1498     /**
1499      * @brief Indexed draw indirect
1500      */
1501     struct
1502     {
1503       const GLES::Buffer* buffer;
1504       uint32_t            offset;
1505       uint32_t            drawCount;
1506       uint32_t            stride;
1507     } drawIndexedIndirect;
1508   };
1509 };
1510
1511 /**
1512  * @brief Topologu conversion from Graphics to GLES
1513  */
1514 struct GLESTopology
1515 {
1516   explicit constexpr GLESTopology(PrimitiveTopology topology)
1517   {
1518     switch(topology)
1519     {
1520       case PrimitiveTopology::POINT_LIST:
1521       {
1522         primitiveTopology = GL_POINTS;
1523         break;
1524       }
1525       case PrimitiveTopology::LINE_LIST:
1526       {
1527         primitiveTopology = GL_LINES;
1528         break;
1529       }
1530       case PrimitiveTopology::LINE_LOOP:
1531       {
1532         primitiveTopology = GL_LINE_LOOP;
1533         break;
1534       }
1535       case PrimitiveTopology::LINE_STRIP:
1536       {
1537         primitiveTopology = GL_LINE_STRIP;
1538         break;
1539       }
1540       case PrimitiveTopology::TRIANGLE_LIST:
1541       {
1542         primitiveTopology = GL_TRIANGLES;
1543         break;
1544       }
1545       case PrimitiveTopology::TRIANGLE_STRIP:
1546       {
1547         primitiveTopology = GL_TRIANGLE_STRIP;
1548         break;
1549       }
1550       case PrimitiveTopology::TRIANGLE_FAN:
1551       {
1552         primitiveTopology = GL_TRIANGLE_FAN;
1553         break;
1554       }
1555     }
1556   }
1557
1558   /**
1559    * @brief Explicit type conversion operator
1560    * @return converted value
1561    */
1562   constexpr inline operator GLenum() const
1563   {
1564     return primitiveTopology;
1565   }
1566
1567   GLenum primitiveTopology{0}; ///< Topology
1568 };
1569
1570 /**
1571  * @brief Index format conversion structure
1572  */
1573 struct GLIndexFormat
1574 {
1575   explicit constexpr GLIndexFormat(Format _format)
1576   {
1577     switch(_format)
1578     {
1579       // TODO: add more formats
1580       case Format::R16_UINT:
1581       {
1582         format = GL_UNSIGNED_SHORT;
1583         break;
1584       }
1585       default:
1586       {
1587         format = 0;
1588       }
1589     }
1590   }
1591
1592   /**
1593    * @brief Explicit type conversion operator
1594    * @return converted value
1595    */
1596   constexpr inline operator GLenum() const
1597   {
1598     return format;
1599   }
1600
1601   GLenum format{0}; ///< Converted format
1602 };
1603
1604 /**
1605  * @brief Conversion of blending function factor
1606  */
1607 struct GLBlendFunc
1608 {
1609   constexpr explicit GLBlendFunc(Graphics::BlendFactor factor)
1610   {
1611     switch(factor)
1612     {
1613       case Graphics::BlendFactor::ZERO:
1614       {
1615         glFactor = GL_ZERO;
1616         break;
1617       }
1618       case Graphics::BlendFactor::ONE:
1619       {
1620         glFactor = GL_ONE;
1621         break;
1622       }
1623       case Graphics::BlendFactor::SRC_COLOR:
1624       {
1625         glFactor = GL_SRC_COLOR;
1626         break;
1627       }
1628       case Graphics::BlendFactor::ONE_MINUS_SRC_COLOR:
1629       {
1630         glFactor = GL_ONE_MINUS_SRC_COLOR;
1631         break;
1632       }
1633       case Graphics::BlendFactor::DST_COLOR:
1634       {
1635         glFactor = GL_DST_COLOR;
1636         break;
1637       }
1638       case Graphics::BlendFactor::ONE_MINUS_DST_COLOR:
1639       {
1640         glFactor = GL_ONE_MINUS_DST_COLOR;
1641         break;
1642       }
1643       case Graphics::BlendFactor::SRC_ALPHA:
1644       {
1645         glFactor = GL_SRC_ALPHA;
1646         break;
1647       }
1648       case Graphics::BlendFactor::ONE_MINUS_SRC_ALPHA:
1649       {
1650         glFactor = GL_ONE_MINUS_SRC_ALPHA;
1651         break;
1652       }
1653       case Graphics::BlendFactor::DST_ALPHA:
1654       {
1655         glFactor = GL_DST_ALPHA;
1656         break;
1657       }
1658       case Graphics::BlendFactor::ONE_MINUS_DST_ALPHA:
1659       {
1660         glFactor = GL_ONE_MINUS_DST_ALPHA;
1661         break;
1662       }
1663       case Graphics::BlendFactor::CONSTANT_COLOR:
1664       {
1665         glFactor = GL_CONSTANT_COLOR;
1666         break;
1667       }
1668       case Graphics::BlendFactor::ONE_MINUS_CONSTANT_COLOR:
1669       {
1670         glFactor = GL_ONE_MINUS_CONSTANT_COLOR;
1671         break;
1672       }
1673       case Graphics::BlendFactor::CONSTANT_ALPHA:
1674       {
1675         glFactor = GL_CONSTANT_ALPHA;
1676         break;
1677       }
1678       case Graphics::BlendFactor::ONE_MINUS_CONSTANT_ALPHA:
1679       {
1680         glFactor = GL_ONE_MINUS_CONSTANT_ALPHA;
1681         break;
1682       }
1683       case Graphics::BlendFactor::SRC_ALPHA_SATURATE:
1684       {
1685         glFactor = GL_SRC_ALPHA_SATURATE;
1686         break;
1687       }
1688       // Below may be unsupported without extension
1689       case Graphics::BlendFactor::SRC1_COLOR:
1690       {
1691         glFactor = 0u;
1692         break;
1693       }
1694       case Graphics::BlendFactor::ONE_MINUS_SRC1_COLOR:
1695       {
1696         glFactor = 0u;
1697         break;
1698       }
1699       case Graphics::BlendFactor::SRC1_ALPHA:
1700       {
1701         glFactor = 0u;
1702         break;
1703       }
1704       case Graphics::BlendFactor::ONE_MINUS_SRC1_ALPHA:
1705       {
1706         glFactor = 0u;
1707         break;
1708       }
1709     }
1710   }
1711
1712   /**
1713    * @brief Explicit type conversion operator
1714    * @return converted value
1715    */
1716   constexpr inline operator GLenum() const
1717   {
1718     return glFactor;
1719   }
1720
1721   GLenum glFactor{0u};
1722 };
1723
1724 /**
1725  * @brief Converts Blend Op to GL
1726  */
1727 struct GLBlendOp
1728 {
1729   constexpr explicit GLBlendOp(Graphics::BlendOp blendOp)
1730   {
1731     switch(blendOp)
1732     {
1733       case Graphics::BlendOp::ADD:
1734       {
1735         glBlendOp = GL_FUNC_ADD;
1736         break;
1737       }
1738       case Graphics::BlendOp::SUBTRACT:
1739       {
1740         glBlendOp = GL_FUNC_SUBTRACT;
1741         break;
1742       }
1743       case Graphics::BlendOp::REVERSE_SUBTRACT:
1744       {
1745         glBlendOp = GL_FUNC_REVERSE_SUBTRACT;
1746         break;
1747       }
1748       case Graphics::BlendOp::MIN:
1749       {
1750         glBlendOp = GL_MIN;
1751         break;
1752       }
1753       case Graphics::BlendOp::MAX:
1754       {
1755         glBlendOp = GL_MAX;
1756         break;
1757       }
1758     }
1759   }
1760
1761   /**
1762    * @brief Explicit type conversion operator
1763    * @return converted value
1764    */
1765   constexpr inline operator GLenum() const
1766   {
1767     return glBlendOp;
1768   }
1769
1770   GLenum glBlendOp{0u};
1771 };
1772
1773 /**
1774  * @brief Converts GL cull mode
1775  */
1776 struct GLCullMode
1777 {
1778   constexpr explicit GLCullMode(Graphics::CullMode cullMode)
1779   {
1780     switch(cullMode)
1781     {
1782       case Graphics::CullMode::NONE: // this isn't really accepted by GL!
1783       {
1784         glCullMode = GL_NONE;
1785         break;
1786       }
1787       case Graphics::CullMode::FRONT:
1788       {
1789         glCullMode = GL_FRONT;
1790         break;
1791       }
1792       case Graphics::CullMode::BACK:
1793       {
1794         glCullMode = GL_BACK;
1795         break;
1796       }
1797       case Graphics::CullMode::FRONT_AND_BACK:
1798       {
1799         glCullMode = GL_FRONT_AND_BACK;
1800         break;
1801       }
1802     }
1803   }
1804
1805   /**
1806    * @brief Explicit type conversion operator
1807    * @return converted value
1808    */
1809   constexpr inline operator GLenum() const
1810   {
1811     return glCullMode;
1812   }
1813
1814   GLenum glCullMode{0u};
1815 };
1816
1817 /**
1818  * @brief enum with GL types
1819  */
1820 enum class GLType
1821 {
1822   UNDEFINED      = 0x0,
1823   FLOAT_VEC2     = 0x8B50,
1824   FLOAT_VEC3     = 0x8B51,
1825   FLOAT_VEC4     = 0x8B52,
1826   INT_VEC2       = 0x8B53,
1827   INT_VEC3       = 0x8B54,
1828   INT_VEC4       = 0x8B55,
1829   BOOL           = 0x8B56,
1830   BOOL_VEC2      = 0x8B57,
1831   BOOL_VEC3      = 0x8B58,
1832   BOOL_VEC4      = 0x8B59,
1833   FLOAT_MAT2     = 0x8B5A,
1834   FLOAT_MAT3     = 0x8B5B,
1835   FLOAT_MAT4     = 0x8B5C,
1836   SAMPLER_2D     = 0x8B5E,
1837   SAMPLER_CUBE   = 0x8B60,
1838   BYTE           = 0x1400,
1839   UNSIGNED_BYTE  = 0x1401,
1840   SHORT          = 0x1402,
1841   UNSIGNED_SHORT = 0x1403,
1842   INT            = 0x1404,
1843   UNSIGNED_INT   = 0x1405,
1844   FLOAT          = 0x1406,
1845   FIXED          = 0x140C,
1846 };
1847
1848 /**
1849  * @brief GL type conversion (used with reflection)
1850  */
1851 struct GLTypeConversion
1852 {
1853   constexpr explicit GLTypeConversion(GLenum value)
1854   {
1855     switch(value)
1856     {
1857       case GL_FLOAT_VEC2:
1858       {
1859         type = GLType::FLOAT_VEC2;
1860         break;
1861       }
1862       case GL_FLOAT_VEC3:
1863       {
1864         type = GLType::FLOAT_VEC3;
1865         break;
1866       }
1867       case GL_FLOAT_VEC4:
1868       {
1869         type = GLType::FLOAT_VEC4;
1870         break;
1871       }
1872       case GL_INT_VEC2:
1873       {
1874         type = GLType::INT_VEC2;
1875         break;
1876       }
1877       case GL_INT_VEC3:
1878       {
1879         type = GLType::INT_VEC3;
1880         break;
1881       }
1882       case GL_INT_VEC4:
1883       {
1884         type = GLType::INT_VEC4;
1885         break;
1886       }
1887       case GL_BOOL:
1888       {
1889         type = GLType::BOOL;
1890         break;
1891       }
1892       case GL_BOOL_VEC2:
1893       {
1894         type = GLType::BOOL_VEC2;
1895         break;
1896       }
1897       case GL_BOOL_VEC3:
1898       {
1899         type = GLType::BOOL_VEC3;
1900         break;
1901       }
1902       case GL_BOOL_VEC4:
1903       {
1904         type = GLType::BOOL_VEC4;
1905         break;
1906       }
1907       case GL_FLOAT_MAT2:
1908       {
1909         type = GLType::FLOAT_MAT2;
1910         break;
1911       }
1912       case GL_FLOAT_MAT3:
1913       {
1914         type = GLType::FLOAT_MAT3;
1915         break;
1916       }
1917       case GL_FLOAT_MAT4:
1918       {
1919         type = GLType::FLOAT_MAT4;
1920         break;
1921       }
1922       case GL_SAMPLER_2D:
1923       {
1924         type = GLType::SAMPLER_2D;
1925         break;
1926       }
1927       case GL_SAMPLER_CUBE:
1928       {
1929         type = GLType::SAMPLER_CUBE;
1930         break;
1931       }
1932       case GL_FLOAT:
1933       {
1934         type = GLType::FLOAT;
1935         break;
1936       }
1937       default:
1938       {
1939         type = GLType::UNDEFINED;
1940       }
1941     }
1942   }
1943
1944   GLType type{GLType::UNDEFINED};
1945 };
1946
1947 enum class GLESVersion
1948 {
1949   GLES_20 = 20,
1950   GLES_30 = 30,
1951   GLES_31 = 31,
1952   GLES_32 = 32
1953 };
1954
1955 /**
1956  * The descriptor of BeginRenderPass command
1957  */
1958 struct BeginRenderPassDescriptor
1959 {
1960   const GLES::RenderPass*   renderPass{};
1961   const GLES::RenderTarget* renderTarget{};
1962   Rect2D                    renderArea{};
1963   std::vector<ClearValue>   clearValues{};
1964 };
1965
1966 } // namespace Dali::Graphics::GLES
1967
1968 #endif //DALI_GRAPHICS_API_TYPES_H