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         Assign(GL_RGB, GL_HALF_FLOAT);
 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         // GLES 3.0 floating point formats.
 632         Assign(GL_RGB, GL_FLOAT);
 633         break;
 634       }
 635       case Graphics::Format::R32G32B32A32_UINT:
 636       {
 637         Assign(0, 0);
 638         break;
 639       }
 640       case Graphics::Format::R32G32B32A32_SINT:
 641       {
 642         Assign(0, 0);
 643         break;
 644       }
 645       case Graphics::Format::R32G32B32A32_SFLOAT:
 646       {
 647         Assign(0, 0);
 648         break;
 649       }
 650       case Graphics::Format::R64_UINT:
 651       {
 652         Assign(0, 0);
 653         break;
 654       }
 655       case Graphics::Format::R64_SINT:
 656       {
 657         Assign(0, 0);
 658         break;
 659       }
 660       case Graphics::Format::R64_SFLOAT:
 661       {
 662         Assign(0, 0);
 663         break;
 664       }
 665       case Graphics::Format::R64G64_UINT:
 666       {
 667         Assign(0, 0);
 668         break;
 669       }
 670       case Graphics::Format::R64G64_SINT:
 671       {
 672         Assign(0, 0);
 673         break;
 674       }
 675       case Graphics::Format::R64G64_SFLOAT:
 676       {
 677         Assign(0, 0);
 678         break;
 679       }
 680       case Graphics::Format::R64G64B64_UINT:
 681       {
 682         Assign(0, 0);
 683         break;
 684       }
 685       case Graphics::Format::R64G64B64_SINT:
 686       {
 687         Assign(0, 0);
 688         break;
 689       }
 690       case Graphics::Format::R64G64B64_SFLOAT:
 691       {
 692         Assign(0, 0);
 693         break;
 694       }
 695       case Graphics::Format::R64G64B64A64_UINT:
 696       {
 697         Assign(0, 0);
 698         break;
 699       }
 700       case Graphics::Format::R64G64B64A64_SINT:
 701       {
 702         Assign(0, 0);
 703         break;
 704       }
 705       case Graphics::Format::R64G64B64A64_SFLOAT:
 706       {
 707         Assign(0, 0);
 708         break;
 709       }
 710       case Graphics::Format::B10G11R11_UFLOAT_PACK32:
 711       {
 712         Assign(0, 0);
 713         break;
 714       }
 715       case Graphics::Format::E5B9G9R9_UFLOAT_PACK32:
 716       {
 717         Assign(0, 0);
 718         break;
 719       }
 720       case Graphics::Format::D16_UNORM:
 721       {
 722         // GLES 3.0 depth and stencil formats
 723         Assign(GL_DEPTH_COMPONENT, GL_UNSIGNED_INT);
 724         break;
 725       }
 726       case Graphics::Format::X8_D24_UNORM_PACK32:
 727       {
 728         Assign(0, 0);
 729         break;
 730       }
 731       case Graphics::Format::D32_SFLOAT:
 732       {
 733         // GLES 3.0 depth and stencil formats
 734         Assign(GL_DEPTH_COMPONENT, GL_FLOAT);
 735         break;
 736       }
 737       case Graphics::Format::S8_UINT:
 738       {
 739         Assign(0, 0);
 740         break;
 741       }
 742       case Graphics::Format::D16_UNORM_S8_UINT:
 743       {
 744         Assign(0, 0);
 745         break;
 746       }
 747       case Graphics::Format::D24_UNORM_S8_UINT:
 748       {
 749         // GLES 3.0 depth and stencil formats
 750         Assign(GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8);
 751         break;
 752       }
 753       case Graphics::Format::D32_SFLOAT_S8_UINT:
 754       {
 755         Assign(0, 0);
 756         break;
 757       }
 758       case Graphics::Format::BC1_RGB_UNORM_BLOCK:
 759       {
 760         Assign(0, 0);
 761         break;
 762       }
 763       case Graphics::Format::BC1_RGB_SRGB_BLOCK:
 764       {
 765         Assign(0, 0);
 766         break;
 767       }
 768       case Graphics::Format::BC1_RGBA_UNORM_BLOCK:
 769       {
 770         Assign(0, 0);
 771         break;
 772       }
 773       case Graphics::Format::BC1_RGBA_SRGB_BLOCK:
 774       {
 775         Assign(0, 0);
 776         break;
 777       }
 778       case Graphics::Format::BC2_UNORM_BLOCK:
 779       {
 780         Assign(0, 0);
 781         break;
 782       }
 783       case Graphics::Format::BC2_SRGB_BLOCK:
 784       {
 785         Assign(0, 0);
 786         break;
 787       }
 788       case Graphics::Format::BC3_UNORM_BLOCK:
 789       {
 790         Assign(0, 0);
 791         break;
 792       }
 793       case Graphics::Format::BC3_SRGB_BLOCK:
 794       {
 795         Assign(0, 0);
 796         break;
 797       }
 798       case Graphics::Format::BC4_UNORM_BLOCK:
 799       {
 800         Assign(0, 0);
 801         break;
 802       }
 803       case Graphics::Format::BC4_SNORM_BLOCK:
 804       {
 805         Assign(0, 0);
 806         break;
 807       }
 808       case Graphics::Format::BC5_UNORM_BLOCK:
 809       {
 810         Assign(0, 0);
 811         break;
 812       }
 813       case Graphics::Format::BC5_SNORM_BLOCK:
 814       {
 815         Assign(0, 0);
 816         break;
 817       }
 818       case Graphics::Format::BC6H_UFLOAT_BLOCK:
 819       {
 820         Assign(0, 0);
 821         break;
 822       }
 823       case Graphics::Format::BC6H_SFLOAT_BLOCK:
 824       {
 825         Assign(0, 0);
 826         break;
 827       }
 828       case Graphics::Format::BC7_UNORM_BLOCK:
 829       {
 830         Assign(0, 0);
 831         break;
 832       }
 833       case Graphics::Format::BC7_SRGB_BLOCK:
 834       {
 835         Assign(0, 0);
 836         break;
 837       }
 838       case Graphics::Format::ETC2_R8G8B8_UNORM_BLOCK:
 839       {
 840         ///! Using GLES 3.0 standard compressed pixel format COMPRESSED_RGB8_ETC2.
 841         Assign(GL_COMPRESSED_RGB8_ETC2, 0);
 842         break;
 843       }
 844       case Graphics::Format::ETC2_R8G8B8_SRGB_BLOCK:
 845       {
 846         ///! Using GLES 3.0 standard compressed pixel format COMPRESSED_SRGB8_ETC2.
 847         Assign(GL_COMPRESSED_SRGB8_ETC2, 0);
 848         break;
 849       }
 850       case Graphics::Format::ETC2_R8G8B8A1_UNORM_BLOCK:
 851       {
 852         ///! Using GLES 3.0 standard compressed pixel format COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2.
 853         Assign(GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, 0);
 854         break;
 855       }
 856       case Graphics::Format::ETC2_R8G8B8A1_SRGB_BLOCK:
 857       {
 858         ///! Using GLES 3.0 standard compressed pixel format COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2.
 859         Assign(GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, 0);
 860         break;
 861       }
 862       case Graphics::Format::ETC2_R8G8B8A8_UNORM_BLOCK:
 863       {
 864         Assign(0, 0);
 865         break;
 866       }
 867       case Graphics::Format::ETC2_R8G8B8A8_SRGB_BLOCK:
 868       {
 869         Assign(0, 0);
 870         break;
 871       }
 872       case Graphics::Format::EAC_R11_UNORM_BLOCK:
 873       {
 874         ///! Using GLES 3.0 standard compressed pixel format COMPRESSED_R11_EAC.
 875         Assign(GL_COMPRESSED_R11_EAC, 0);
 876         break;
 877       }
 878       case Graphics::Format::EAC_R11_SNORM_BLOCK:
 879       {
 880         ///! Using GLES 3.0 standard compressed pixel format COMPRESSED_SIGNED_R11_EAC.
 881         Assign(GL_COMPRESSED_SIGNED_R11_EAC, 0);
 882         break;
 883       }
 884       case Graphics::Format::EAC_R11G11_UNORM_BLOCK:
 885       {
 886         ///! Using GLES 3.0 standard compressed pixel format COMPRESSED_RG11_EAC.
 887         Assign(GL_COMPRESSED_RG11_EAC, 0);
 888         break;
 889       }
 890       case Graphics::Format::EAC_R11G11_SNORM_BLOCK:
 891       {
 892         ///! Using GLES 3.0 standard compressed pixel format COMPRESSED_SIGNED_RG11_EAC.
 893         Assign(GL_COMPRESSED_SIGNED_RG11_EAC, 0);
 894         break;
 895       }
 896       case Graphics::Format::ASTC_4x4_UNORM_BLOCK:
 897       {
 898         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_4x4_KHR.
 899         Assign(GL_COMPRESSED_RGBA_ASTC_4x4_KHR, 0);
 900         break;
 901       }
 902       case Graphics::Format::ASTC_4x4_SRGB_BLOCK:
 903       {
 904         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR.
 905         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR, 0);
 906         break;
 907       }
 908       case Graphics::Format::ASTC_5x4_UNORM_BLOCK:
 909       {
 910         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_5x4_KHR.
 911         Assign(GL_COMPRESSED_RGBA_ASTC_5x4_KHR, 0);
 912         break;
 913       }
 914       case Graphics::Format::ASTC_5x4_SRGB_BLOCK:
 915       {
 916         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR.
 917         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR, 0);
 918         break;
 919       }
 920       case Graphics::Format::ASTC_5x5_UNORM_BLOCK:
 921       {
 922         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_5x5_KHR.
 923         Assign(GL_COMPRESSED_RGBA_ASTC_5x5_KHR, 0);
 924         break;
 925       }
 926       case Graphics::Format::ASTC_5x5_SRGB_BLOCK:
 927       {
 928         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR.
 929         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR, 0);
 930         break;
 931       }
 932       case Graphics::Format::ASTC_6x5_UNORM_BLOCK:
 933       {
 934         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_6x5_KHR.
 935         Assign(GL_COMPRESSED_RGBA_ASTC_6x5_KHR, 0);
 936         break;
 937       }
 938       case Graphics::Format::ASTC_6x5_SRGB_BLOCK:
 939       {
 940         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR.
 941         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR, 0);
 942         break;
 943       }
 944       case Graphics::Format::ASTC_6x6_UNORM_BLOCK:
 945       {
 946         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_6x6_KHR.
 947         Assign(GL_COMPRESSED_RGBA_ASTC_6x6_KHR, 0);
 948         break;
 949       }
 950       case Graphics::Format::ASTC_6x6_SRGB_BLOCK:
 951       {
 952         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR.
 953         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR, 0);
 954         break;
 955       }
 956       case Graphics::Format::ASTC_8x5_UNORM_BLOCK:
 957       {
 958         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_8x5_KHR.
 959         Assign(GL_COMPRESSED_RGBA_ASTC_8x5_KHR, 0);
 960         break;
 961       }
 962       case Graphics::Format::ASTC_8x5_SRGB_BLOCK:
 963       {
 964         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR.
 965         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR, 0);
 966         break;
 967       }
 968       case Graphics::Format::ASTC_8x6_UNORM_BLOCK:
 969       {
 970         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_8x6_KHR.
 971         Assign(GL_COMPRESSED_RGBA_ASTC_8x6_KHR, 0);
 972         break;
 973       }
 974       case Graphics::Format::ASTC_8x6_SRGB_BLOCK:
 975       {
 976         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR.
 977         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR, 0);
 978         break;
 979       }
 980       case Graphics::Format::ASTC_8x8_UNORM_BLOCK:
 981       {
 982         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_8x8_KHR.
 983         Assign(GL_COMPRESSED_RGBA_ASTC_8x8_KHR, 0);
 984         break;
 985       }
 986       case Graphics::Format::ASTC_8x8_SRGB_BLOCK:
 987       {
 988         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR.
 989         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR, 0);
 990         break;
 991       }
 992       case Graphics::Format::ASTC_10x5_UNORM_BLOCK:
 993       {
 994         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_10x5_KHR.
 995         Assign(GL_COMPRESSED_RGBA_ASTC_10x5_KHR, 0);
 996         break;
 997       }
 998       case Graphics::Format::ASTC_10x5_SRGB_BLOCK:
 999       {
1000         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR.
1001         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR, 0);
1002         break;
1003       }
1004       case Graphics::Format::ASTC_10x6_UNORM_BLOCK:
1005       {
1006         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_10x6_KHR.
1007         Assign(GL_COMPRESSED_RGBA_ASTC_10x6_KHR, 0);
1008         break;
1009       }
1010       case Graphics::Format::ASTC_10x6_SRGB_BLOCK:
1011       {
1012         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR.
1013         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR, 0);
1014         break;
1015       }
1016       case Graphics::Format::ASTC_10x8_UNORM_BLOCK:
1017       {
1018         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_10x8_KHR.
1019         Assign(GL_COMPRESSED_RGBA_ASTC_10x8_KHR, 0);
1020         break;
1021       }
1022       case Graphics::Format::ASTC_10x8_SRGB_BLOCK:
1023       {
1024         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR.
1025         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR, 0);
1026         break;
1027       }
1028       case Graphics::Format::ASTC_10x10_UNORM_BLOCK:
1029       {
1030         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_10x10_KHR.
1031         Assign(GL_COMPRESSED_RGBA_ASTC_10x10_KHR, 0);
1032         break;
1033       }
1034       case Graphics::Format::ASTC_10x10_SRGB_BLOCK:
1035       {
1036         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR.
1037         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR, 0);
1038         break;
1039       }
1040       case Graphics::Format::ASTC_12x10_UNORM_BLOCK:
1041       {
1042         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_12x10_KHR.
1043         Assign(GL_COMPRESSED_RGBA_ASTC_12x10_KHR, 0);
1044         break;
1045       }
1046       case Graphics::Format::ASTC_12x10_SRGB_BLOCK:
1047       {
1048         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR.
1049         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR, 0);
1050         break;
1051       }
1052       case Graphics::Format::ASTC_12x12_UNORM_BLOCK:
1053       {
1054         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_12x12_KHR.
1055         Assign(GL_COMPRESSED_RGBA_ASTC_12x12_KHR, 0);
1056         break;
1057       }
1058       case Graphics::Format::ASTC_12x12_SRGB_BLOCK:
1059       {
1060         ///! Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR.
1061         Assign(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR, 0);
1062         break;
1063       }
1064       case Graphics::Format::PVRTC1_2BPP_UNORM_BLOCK_IMG:
1065       {
1066         Assign(0, 0);
1067         break;
1068       }
1069       case Graphics::Format::PVRTC1_4BPP_UNORM_BLOCK_IMG:
1070       {
1071         ///! Using non-standard GLES 2.0 extension compressed pixel format COMPRESSED_RGB_PVRTC_4BPPV1.
1072         Assign(0x8C00, 0); ///! < Hardcoded so we can test before we move to GLES 3.0 or greater.
1073
1074         break;
1075       }
1076       case Graphics::Format::PVRTC2_2BPP_UNORM_BLOCK_IMG:
1077       {
1078         Assign(0, 0);
1079         break;
1080       }
1081       case Graphics::Format::PVRTC2_4BPP_UNORM_BLOCK_IMG:
1082       {
1083         Assign(0, 0);
1084         break;
1085       }
1086       case Graphics::Format::PVRTC1_2BPP_SRGB_BLOCK_IMG:
1087       {
1088         Assign(0, 0);
1089         break;
1090       }
1091       case Graphics::Format::PVRTC1_4BPP_SRGB_BLOCK_IMG:
1092       {
1093         Assign(0, 0);
1094         break;
1095       }
1096       case Graphics::Format::PVRTC2_2BPP_SRGB_BLOCK_IMG:
1097       {
1098         Assign(0, 0);
1099         break;
1100       }
1101       case Graphics::Format::PVRTC2_4BPP_SRGB_BLOCK_IMG:
1102       {
1103         Assign(0, 0);
1104         break;
1105       }
1106     }
1107   }
1108
1109   constexpr inline void Assign(uint32_t f, uint32_t t)
1110   {
1111     format = f;
1112     type   = t;
1113   }
1114
1115   uint32_t format{0};
1116   uint32_t type{0};
1117 };
1118
1119 struct GLSamplerFilter
1120 {
1121   constexpr explicit GLSamplerFilter(Graphics::SamplerFilter filter)
1122   {
1123     switch(filter)
1124     {
1125       case Graphics::SamplerFilter::NEAREST:
1126       {
1127         glFilter = GL_NEAREST;
1128         break;
1129       }
1130       case Graphics::SamplerFilter::LINEAR:
1131       {
1132         glFilter = GL_LINEAR;
1133         break;
1134       }
1135     }
1136   }
1137   uint32_t glFilter{0};
1138 };
1139
1140 struct GLSamplerFilterAndMipMapMode
1141 {
1142   constexpr explicit GLSamplerFilterAndMipMapMode(Graphics::SamplerFilter     filter,
1143                                                   Graphics::SamplerMipmapMode mipMapMode)
1144   {
1145     switch(filter)
1146     {
1147       case Graphics::SamplerFilter::NEAREST:
1148       {
1149         switch(mipMapMode)
1150         {
1151           case Graphics::SamplerMipmapMode::NONE:
1152           {
1153             glFilter = GL_NEAREST;
1154             break;
1155           }
1156           case Graphics::SamplerMipmapMode::NEAREST:
1157           {
1158             glFilter = GL_NEAREST_MIPMAP_NEAREST;
1159             break;
1160           }
1161           case Graphics::SamplerMipmapMode::LINEAR:
1162           {
1163             glFilter = GL_NEAREST_MIPMAP_LINEAR;
1164             break;
1165           }
1166         }
1167         break;
1168       }
1169
1170       case Graphics::SamplerFilter::LINEAR:
1171       {
1172         switch(mipMapMode)
1173         {
1174           case Graphics::SamplerMipmapMode::NONE:
1175           {
1176             glFilter = GL_LINEAR;
1177             break;
1178           }
1179           case Graphics::SamplerMipmapMode::NEAREST:
1180           {
1181             glFilter = GL_LINEAR_MIPMAP_NEAREST;
1182             break;
1183           }
1184           case Graphics::SamplerMipmapMode::LINEAR:
1185           {
1186             glFilter = GL_LINEAR_MIPMAP_LINEAR;
1187             break;
1188           }
1189         }
1190         break;
1191       }
1192     }
1193   }
1194
1195   inline explicit operator uint32_t() const
1196   {
1197     return glFilter;
1198   }
1199
1200   inline operator int() const
1201   {
1202     return static_cast<int>(glFilter);
1203   }
1204
1205   uint32_t glFilter{0};
1206 };
1207
1208 /** Converts vertex format to GL */
1209 struct GLVertexFormat
1210 {
1211   constexpr explicit GLVertexFormat(Graphics::VertexInputFormat gfxFormat)
1212   {
1213     switch(gfxFormat)
1214     {
1215       case VertexInputFormat::FVECTOR2:
1216       {
1217         format = GL_FLOAT;
1218         size   = 2;
1219         break;
1220       }
1221       case VertexInputFormat::FVECTOR3:
1222       {
1223         format = GL_FLOAT;
1224         size   = 3;
1225         break;
1226       }
1227       case VertexInputFormat::FVECTOR4:
1228       {
1229         format = GL_FLOAT;
1230         size   = 4;
1231         break;
1232       }
1233       case VertexInputFormat::FLOAT:
1234       {
1235         format = GL_FLOAT;
1236         size   = 1;
1237         break;
1238       }
1239       case VertexInputFormat::INTEGER:
1240       {
1241         format = GL_INT;
1242         size   = 1;
1243         break;
1244       }
1245       case VertexInputFormat::IVECTOR2:
1246       {
1247         format = GL_INT;
1248         size   = 2;
1249         break;
1250       }
1251       case VertexInputFormat::IVECTOR3:
1252       {
1253         format = GL_INT;
1254         size   = 3;
1255         break;
1256       }
1257       case VertexInputFormat::IVECTOR4:
1258       {
1259         format = GL_INT;
1260         size   = 4;
1261         break;
1262       }
1263       case VertexInputFormat::UNDEFINED:
1264       {
1265         format = 0;
1266         size   = 0;
1267         break;
1268       }
1269     }
1270   }
1271
1272   GLenum   format{0u};
1273   uint32_t size{0u};
1274 };
1275
1276 struct GLTextureTarget
1277 {
1278   constexpr explicit GLTextureTarget(Graphics::TextureType graphicsTextureType)
1279   {
1280     switch(graphicsTextureType)
1281     {
1282       case Graphics::TextureType::TEXTURE_2D:
1283       {
1284         target = GL_TEXTURE_2D;
1285         break;
1286       }
1287       case Graphics::TextureType::TEXTURE_3D:
1288       {
1289         target = GL_TEXTURE_3D;
1290         break;
1291       }
1292       case Graphics::TextureType::TEXTURE_CUBEMAP:
1293       {
1294         target = GL_TEXTURE_CUBE_MAP;
1295         break;
1296       }
1297     }
1298   }
1299   GLenum target{GL_TEXTURE_2D};
1300 };
1301
1302 struct GLAddressMode
1303 {
1304   constexpr explicit GLAddressMode(Graphics::SamplerAddressMode graphicsAddressMode)
1305   {
1306     switch(graphicsAddressMode)
1307     {
1308       case Graphics::SamplerAddressMode::REPEAT:
1309       {
1310         texParameter = GL_REPEAT;
1311         break;
1312       }
1313       case Graphics::SamplerAddressMode::MIRRORED_REPEAT:
1314       {
1315         texParameter = GL_MIRRORED_REPEAT;
1316         break;
1317       }
1318       case Graphics::SamplerAddressMode::CLAMP_TO_EDGE:
1319       {
1320         texParameter = GL_CLAMP_TO_EDGE;
1321         break;
1322       }
1323       case Graphics::SamplerAddressMode::CLAMP_TO_BORDER:
1324       {
1325         texParameter = GL_CLAMP_TO_EDGE;
1326         break;
1327       }
1328       case Graphics::SamplerAddressMode::MIRROR_CLAMP_TO_EDGE:
1329       {
1330         texParameter = GL_CLAMP_TO_EDGE;
1331         break;
1332       }
1333     }
1334   }
1335   GLenum texParameter{GL_CLAMP_TO_EDGE};
1336 };
1337
1338 struct GLCompareOp
1339 {
1340   constexpr explicit GLCompareOp(Graphics::CompareOp compareOp)
1341   {
1342     switch(compareOp)
1343     {
1344       case Graphics::CompareOp::NEVER:
1345         op = GL_NEVER;
1346         break;
1347       case Graphics::CompareOp::LESS:
1348         op = GL_LESS;
1349         break;
1350       case Graphics::CompareOp::EQUAL:
1351         op = GL_EQUAL;
1352         break;
1353       case Graphics::CompareOp::LESS_OR_EQUAL:
1354         op = GL_LEQUAL;
1355         break;
1356       case Graphics::CompareOp::GREATER:
1357         op = GL_GREATER;
1358         break;
1359       case Graphics::CompareOp::NOT_EQUAL:
1360         op = GL_NOTEQUAL;
1361         break;
1362       case Graphics::CompareOp::GREATER_OR_EQUAL:
1363         op = GL_GEQUAL;
1364         break;
1365       case Graphics::CompareOp::ALWAYS:
1366         op = GL_ALWAYS;
1367         break;
1368     }
1369   }
1370   GLenum op{GL_LESS};
1371 };
1372
1373 struct GLStencilOp
1374 {
1375   constexpr explicit GLStencilOp(Graphics::StencilOp stencilOp)
1376   {
1377     switch(stencilOp)
1378     {
1379       case Graphics::StencilOp::KEEP:
1380         op = GL_KEEP;
1381         break;
1382       case Graphics::StencilOp::ZERO:
1383         op = GL_ZERO;
1384         break;
1385       case Graphics::StencilOp::REPLACE:
1386         op = GL_REPLACE;
1387         break;
1388       case Graphics::StencilOp::INCREMENT_AND_CLAMP:
1389         op = GL_INCR;
1390         break;
1391       case Graphics::StencilOp::DECREMENT_AND_CLAMP:
1392         op = GL_DECR;
1393         break;
1394       case Graphics::StencilOp::INVERT:
1395         op = GL_INVERT;
1396         break;
1397       case Graphics::StencilOp::INCREMENT_AND_WRAP:
1398         op = GL_INCR_WRAP;
1399         break;
1400       case Graphics::StencilOp::DECREMENT_AND_WRAP:
1401         op = GL_DECR_WRAP;
1402         break;
1403     }
1404   }
1405   GLenum op{GL_KEEP};
1406 };
1407
1408 /**
1409  * @brief Descriptor of single buffer binding within
1410  * command buffer.
1411  */
1412 struct VertexBufferBindingDescriptor
1413 {
1414   const GLES::Buffer* buffer{nullptr};
1415   uint32_t            offset{0u};
1416 };
1417
1418 /**
1419  * @brief Descriptor of ix buffer binding within
1420  * command buffer.
1421  */
1422 struct IndexBufferBindingDescriptor
1423 {
1424   const GLES::Buffer* buffer{nullptr};
1425   uint32_t            offset{};
1426   Graphics::Format    format{};
1427 };
1428
1429 /**
1430  * @brief Descriptor of uniform buffer binding within
1431  * command buffer.
1432  */
1433 struct UniformBufferBindingDescriptor
1434 {
1435   const GLES::Buffer* buffer{nullptr};
1436   uint32_t            binding{0u};
1437   uint32_t            offset{0u};
1438   bool                emulated; ///<true if UBO is emulated for old gfx API
1439 };
1440
1441 /**
1442  * @brief The descriptor of draw call
1443  */
1444 struct DrawCallDescriptor
1445 {
1446   /**
1447    * @brief Enum specifying type of the draw call
1448    */
1449   enum class Type
1450   {
1451     DRAW,
1452     DRAW_INDEXED,
1453     DRAW_INDEXED_INDIRECT
1454   };
1455
1456   Type type{}; ///< Type of the draw call
1457
1458   /**
1459    * Union contains data for all types of draw calls.
1460    */
1461   union
1462   {
1463     /**
1464      * @brief Vertex array draw
1465      */
1466     struct
1467     {
1468       uint32_t vertexCount;
1469       uint32_t instanceCount;
1470       uint32_t firstVertex;
1471       uint32_t firstInstance;
1472     } draw;
1473
1474     /**
1475      * @brief Indexed draw
1476      */
1477     struct
1478     {
1479       uint32_t indexCount;
1480       uint32_t instanceCount;
1481       uint32_t firstIndex;
1482       int32_t  vertexOffset;
1483       uint32_t firstInstance;
1484     } drawIndexed;
1485
1486     /**
1487      * @brief Indexed draw indirect
1488      */
1489     struct
1490     {
1491       const GLES::Buffer* buffer;
1492       uint32_t            offset;
1493       uint32_t            drawCount;
1494       uint32_t            stride;
1495     } drawIndexedIndirect;
1496   };
1497 };
1498
1499 /**
1500  * @brief Topologu conversion from Graphics to GLES
1501  */
1502 struct GLESTopology
1503 {
1504   explicit constexpr GLESTopology(PrimitiveTopology topology)
1505   {
1506     switch(topology)
1507     {
1508       case PrimitiveTopology::POINT_LIST:
1509       {
1510         primitiveTopology = GL_POINTS;
1511         break;
1512       }
1513       case PrimitiveTopology::LINE_LIST:
1514       {
1515         primitiveTopology = GL_LINES;
1516         break;
1517       }
1518       case PrimitiveTopology::LINE_LOOP:
1519       {
1520         primitiveTopology = GL_LINE_LOOP;
1521         break;
1522       }
1523       case PrimitiveTopology::LINE_STRIP:
1524       {
1525         primitiveTopology = GL_LINE_STRIP;
1526         break;
1527       }
1528       case PrimitiveTopology::TRIANGLE_LIST:
1529       {
1530         primitiveTopology = GL_TRIANGLES;
1531         break;
1532       }
1533       case PrimitiveTopology::TRIANGLE_STRIP:
1534       {
1535         primitiveTopology = GL_TRIANGLE_STRIP;
1536         break;
1537       }
1538       case PrimitiveTopology::TRIANGLE_FAN:
1539       {
1540         primitiveTopology = GL_TRIANGLE_FAN;
1541         break;
1542       }
1543     }
1544   }
1545
1546   /**
1547    * @brief Explicit type conversion operator
1548    * @return converted value
1549    */
1550   constexpr inline operator GLenum() const
1551   {
1552     return primitiveTopology;
1553   }
1554
1555   GLenum primitiveTopology{0}; ///< Topology
1556 };
1557
1558 /**
1559  * @brief Index format conversion structure
1560  */
1561 struct GLIndexFormat
1562 {
1563   explicit constexpr GLIndexFormat(Format _format)
1564   {
1565     switch(_format)
1566     {
1567       // TODO: add more formats
1568       case Format::R16_UINT:
1569       {
1570         format = GL_UNSIGNED_SHORT;
1571         break;
1572       }
1573       default:
1574       {
1575         format = 0;
1576       }
1577     }
1578   }
1579
1580   /**
1581    * @brief Explicit type conversion operator
1582    * @return converted value
1583    */
1584   constexpr inline operator GLenum() const
1585   {
1586     return format;
1587   }
1588
1589   GLenum format{0}; ///< Converted format
1590 };
1591
1592 /**
1593  * @brief Conversion of blending function factor
1594  */
1595 struct GLBlendFunc
1596 {
1597   constexpr explicit GLBlendFunc(Graphics::BlendFactor factor)
1598   {
1599     switch(factor)
1600     {
1601       case Graphics::BlendFactor::ZERO:
1602       {
1603         glFactor = GL_ZERO;
1604         break;
1605       }
1606       case Graphics::BlendFactor::ONE:
1607       {
1608         glFactor = GL_ONE;
1609         break;
1610       }
1611       case Graphics::BlendFactor::SRC_COLOR:
1612       {
1613         glFactor = GL_SRC_COLOR;
1614         break;
1615       }
1616       case Graphics::BlendFactor::ONE_MINUS_SRC_COLOR:
1617       {
1618         glFactor = GL_ONE_MINUS_SRC_COLOR;
1619         break;
1620       }
1621       case Graphics::BlendFactor::DST_COLOR:
1622       {
1623         glFactor = GL_DST_COLOR;
1624         break;
1625       }
1626       case Graphics::BlendFactor::ONE_MINUS_DST_COLOR:
1627       {
1628         glFactor = GL_ONE_MINUS_DST_COLOR;
1629         break;
1630       }
1631       case Graphics::BlendFactor::SRC_ALPHA:
1632       {
1633         glFactor = GL_SRC_ALPHA;
1634         break;
1635       }
1636       case Graphics::BlendFactor::ONE_MINUS_SRC_ALPHA:
1637       {
1638         glFactor = GL_ONE_MINUS_SRC_ALPHA;
1639         break;
1640       }
1641       case Graphics::BlendFactor::DST_ALPHA:
1642       {
1643         glFactor = GL_DST_ALPHA;
1644         break;
1645       }
1646       case Graphics::BlendFactor::ONE_MINUS_DST_ALPHA:
1647       {
1648         glFactor = GL_ONE_MINUS_DST_ALPHA;
1649         break;
1650       }
1651       case Graphics::BlendFactor::CONSTANT_COLOR:
1652       {
1653         glFactor = GL_CONSTANT_COLOR;
1654         break;
1655       }
1656       case Graphics::BlendFactor::ONE_MINUS_CONSTANT_COLOR:
1657       {
1658         glFactor = GL_ONE_MINUS_CONSTANT_COLOR;
1659         break;
1660       }
1661       case Graphics::BlendFactor::CONSTANT_ALPHA:
1662       {
1663         glFactor = GL_CONSTANT_ALPHA;
1664         break;
1665       }
1666       case Graphics::BlendFactor::ONE_MINUS_CONSTANT_ALPHA:
1667       {
1668         glFactor = GL_ONE_MINUS_CONSTANT_ALPHA;
1669         break;
1670       }
1671       case Graphics::BlendFactor::SRC_ALPHA_SATURATE:
1672       {
1673         glFactor = GL_SRC_ALPHA_SATURATE;
1674         break;
1675       }
1676       // Below may be unsupported without extension
1677       case Graphics::BlendFactor::SRC1_COLOR:
1678       {
1679         glFactor = 0u;
1680         break;
1681       }
1682       case Graphics::BlendFactor::ONE_MINUS_SRC1_COLOR:
1683       {
1684         glFactor = 0u;
1685         break;
1686       }
1687       case Graphics::BlendFactor::SRC1_ALPHA:
1688       {
1689         glFactor = 0u;
1690         break;
1691       }
1692       case Graphics::BlendFactor::ONE_MINUS_SRC1_ALPHA:
1693       {
1694         glFactor = 0u;
1695         break;
1696       }
1697     }
1698   }
1699
1700   /**
1701    * @brief Explicit type conversion operator
1702    * @return converted value
1703    */
1704   constexpr inline operator GLenum() const
1705   {
1706     return glFactor;
1707   }
1708
1709   GLenum glFactor{0u};
1710 };
1711
1712 /**
1713  * @brief Converts Blend Op to GL
1714  */
1715 struct GLBlendOp
1716 {
1717   constexpr explicit GLBlendOp(Graphics::BlendOp blendOp)
1718   {
1719     switch(blendOp)
1720     {
1721       case Graphics::BlendOp::ADD:
1722       {
1723         glBlendOp = GL_FUNC_ADD;
1724         break;
1725       }
1726       case Graphics::BlendOp::SUBTRACT:
1727       {
1728         glBlendOp = GL_FUNC_SUBTRACT;
1729         break;
1730       }
1731       case Graphics::BlendOp::REVERSE_SUBTRACT:
1732       {
1733         glBlendOp = GL_FUNC_REVERSE_SUBTRACT;
1734         break;
1735       }
1736       case Graphics::BlendOp::MIN:
1737       {
1738         glBlendOp = GL_MIN;
1739         break;
1740       }
1741       case Graphics::BlendOp::MAX:
1742       {
1743         glBlendOp = GL_MAX;
1744         break;
1745       }
1746     }
1747   }
1748
1749   /**
1750    * @brief Explicit type conversion operator
1751    * @return converted value
1752    */
1753   constexpr inline operator GLenum() const
1754   {
1755     return glBlendOp;
1756   }
1757
1758   GLenum glBlendOp{0u};
1759 };
1760
1761 /**
1762  * @brief Converts GL cull mode
1763  */
1764 struct GLCullMode
1765 {
1766   constexpr explicit GLCullMode(Graphics::CullMode cullMode)
1767   {
1768     switch(cullMode)
1769     {
1770       case Graphics::CullMode::NONE: // this isn't really accepted by GL!
1771       {
1772         glCullMode = GL_NONE;
1773         break;
1774       }
1775       case Graphics::CullMode::FRONT:
1776       {
1777         glCullMode = GL_FRONT;
1778         break;
1779       }
1780       case Graphics::CullMode::BACK:
1781       {
1782         glCullMode = GL_BACK;
1783         break;
1784       }
1785       case Graphics::CullMode::FRONT_AND_BACK:
1786       {
1787         glCullMode = GL_FRONT_AND_BACK;
1788         break;
1789       }
1790     }
1791   }
1792
1793   /**
1794    * @brief Explicit type conversion operator
1795    * @return converted value
1796    */
1797   constexpr inline operator GLenum() const
1798   {
1799     return glCullMode;
1800   }
1801
1802   GLenum glCullMode{0u};
1803 };
1804
1805 /**
1806  * @brief enum with GL types
1807  */
1808 enum class GLType
1809 {
1810   UNDEFINED      = 0x0,
1811   FLOAT_VEC2     = 0x8B50,
1812   FLOAT_VEC3     = 0x8B51,
1813   FLOAT_VEC4     = 0x8B52,
1814   INT_VEC2       = 0x8B53,
1815   INT_VEC3       = 0x8B54,
1816   INT_VEC4       = 0x8B55,
1817   BOOL           = 0x8B56,
1818   BOOL_VEC2      = 0x8B57,
1819   BOOL_VEC3      = 0x8B58,
1820   BOOL_VEC4      = 0x8B59,
1821   FLOAT_MAT2     = 0x8B5A,
1822   FLOAT_MAT3     = 0x8B5B,
1823   FLOAT_MAT4     = 0x8B5C,
1824   SAMPLER_2D     = 0x8B5E,
1825   SAMPLER_CUBE   = 0x8B60,
1826   BYTE           = 0x1400,
1827   UNSIGNED_BYTE  = 0x1401,
1828   SHORT          = 0x1402,
1829   UNSIGNED_SHORT = 0x1403,
1830   INT            = 0x1404,
1831   UNSIGNED_INT   = 0x1405,
1832   FLOAT          = 0x1406,
1833   FIXED          = 0x140C,
1834 };
1835
1836 /**
1837  * @brief GL type conversion (used with reflection)
1838  */
1839 struct GLTypeConversion
1840 {
1841   constexpr explicit GLTypeConversion(GLenum value)
1842   {
1843     switch(value)
1844     {
1845       case GL_FLOAT_VEC2:
1846       {
1847         type = GLType::FLOAT_VEC2;
1848         break;
1849       }
1850       case GL_FLOAT_VEC3:
1851       {
1852         type = GLType::FLOAT_VEC3;
1853         break;
1854       }
1855       case GL_FLOAT_VEC4:
1856       {
1857         type = GLType::FLOAT_VEC4;
1858         break;
1859       }
1860       case GL_INT_VEC2:
1861       {
1862         type = GLType::INT_VEC2;
1863         break;
1864       }
1865       case GL_INT_VEC3:
1866       {
1867         type = GLType::INT_VEC3;
1868         break;
1869       }
1870       case GL_INT_VEC4:
1871       {
1872         type = GLType::INT_VEC4;
1873         break;
1874       }
1875       case GL_BOOL:
1876       {
1877         type = GLType::BOOL;
1878         break;
1879       }
1880       case GL_BOOL_VEC2:
1881       {
1882         type = GLType::BOOL_VEC2;
1883         break;
1884       }
1885       case GL_BOOL_VEC3:
1886       {
1887         type = GLType::BOOL_VEC3;
1888         break;
1889       }
1890       case GL_BOOL_VEC4:
1891       {
1892         type = GLType::BOOL_VEC4;
1893         break;
1894       }
1895       case GL_FLOAT_MAT2:
1896       {
1897         type = GLType::FLOAT_MAT2;
1898         break;
1899       }
1900       case GL_FLOAT_MAT3:
1901       {
1902         type = GLType::FLOAT_MAT3;
1903         break;
1904       }
1905       case GL_FLOAT_MAT4:
1906       {
1907         type = GLType::FLOAT_MAT4;
1908         break;
1909       }
1910       case GL_SAMPLER_2D:
1911       {
1912         type = GLType::SAMPLER_2D;
1913         break;
1914       }
1915       case GL_SAMPLER_CUBE:
1916       {
1917         type = GLType::SAMPLER_CUBE;
1918         break;
1919       }
1920       case GL_FLOAT:
1921       {
1922         type = GLType::FLOAT;
1923         break;
1924       }
1925       default:
1926       {
1927         type = GLType::UNDEFINED;
1928       }
1929     }
1930   }
1931
1932   GLType type{GLType::UNDEFINED};
1933 };
1934
1935 enum class GLESVersion
1936 {
1937   GLES_20 = 20,
1938   GLES_30 = 30,
1939   GLES_31 = 31,
1940   GLES_32 = 32
1941 };
1942
1943 /**
1944  * The descriptor of BeginRenderPass command
1945  */
1946 struct BeginRenderPassDescriptor
1947 {
1948   const GLES::RenderPass*   renderPass{};
1949   const GLES::RenderTarget* renderTarget{};
1950   Rect2D                    renderArea{};
1951   std::vector<ClearValue>   clearValues{};
1952 };
1953
1954 } // namespace Dali::Graphics::GLES
1955
1956 #endif //DALI_GRAPHICS_API_TYPES_H