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