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