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 The descriptor of draw call
1274  */
1275 struct DrawCallDescriptor
1276 {
1277   /**
1278    * @brief Enum specifying type of the draw call
1279    */
1280   enum class Type
1281   {
1282     DRAW,
1283     DRAW_INDEXED,
1284     DRAW_INDEXED_INDIRECT
1285   };
1286
1287   Type type{}; ///< Type of the draw call
1288
1289   /**
1290    * Union contains data for all types of draw calls.
1291    */
1292   union
1293   {
1294     /**
1295      * @brief Vertex array draw
1296      */
1297     struct
1298     {
1299       uint32_t vertexCount;
1300       uint32_t instanceCount;
1301       uint32_t firstVertex;
1302       uint32_t firstInstance;
1303     } draw;
1304
1305     /**
1306      * @brief Indexed draw
1307      */
1308     struct
1309     {
1310       uint32_t indexCount;
1311       uint32_t instanceCount;
1312       uint32_t firstIndex;
1313       int32_t  vertexOffset;
1314       uint32_t firstInstance;
1315     } drawIndexed;
1316
1317     /**
1318      * @brief Indexed draw indirect
1319      */
1320     struct
1321     {
1322       const GLES::Buffer* buffer;
1323       uint32_t            offset;
1324       uint32_t            drawCount;
1325       uint32_t            stride;
1326     } drawIndexedIndirect;
1327   };
1328 };
1329
1330 /**
1331  * @brief Topologu conversion from Graphics to GLES
1332  */
1333 struct GLESTopology
1334 {
1335   explicit constexpr GLESTopology(PrimitiveTopology topology)
1336   {
1337     switch(topology)
1338     {
1339       case PrimitiveTopology::POINT_LIST:
1340       {
1341         primitiveTopology = GL_POINTS;
1342         break;
1343       }
1344       case PrimitiveTopology::LINE_LIST:
1345       {
1346         primitiveTopology = GL_LINES;
1347         break;
1348       }
1349       case PrimitiveTopology::LINE_LOOP:
1350       {
1351         primitiveTopology = GL_LINE_LOOP;
1352         break;
1353       }
1354       case PrimitiveTopology::LINE_STRIP:
1355       {
1356         primitiveTopology = GL_LINE_STRIP;
1357         break;
1358       }
1359       case PrimitiveTopology::TRIANGLE_LIST:
1360       {
1361         primitiveTopology = GL_TRIANGLES;
1362         break;
1363       }
1364       case PrimitiveTopology::TRIANGLE_STRIP:
1365       {
1366         primitiveTopology = GL_TRIANGLE_STRIP;
1367         break;
1368       }
1369       case PrimitiveTopology::TRIANGLE_FAN:
1370       {
1371         primitiveTopology = GL_TRIANGLE_FAN;
1372         break;
1373       }
1374     }
1375   }
1376
1377   /**
1378    * @brief Explicit type conversion operator
1379    * @return converted value
1380    */
1381   constexpr inline operator GLenum() const
1382   {
1383     return primitiveTopology;
1384   }
1385
1386   GLenum primitiveTopology{0}; ///< Topology
1387 };
1388
1389 /**
1390  * @brief Index format conversion structure
1391  */
1392 struct GLIndexFormat
1393 {
1394   explicit constexpr GLIndexFormat(Format _format)
1395   {
1396     switch(_format)
1397     {
1398       // TODO: add more formats
1399       case Format::R16_UINT:
1400       {
1401         format = GL_UNSIGNED_SHORT;
1402         break;
1403       }
1404       default:
1405       {
1406         format = 0;
1407       }
1408     }
1409   }
1410
1411   /**
1412    * @brief Explicit type conversion operator
1413    * @return converted value
1414    */
1415   constexpr inline operator GLenum() const
1416   {
1417     return format;
1418   }
1419
1420   GLenum format{0}; ///< Converted format
1421 };
1422
1423 /**
1424  * @brief Conversion of blending function factor
1425  */
1426 struct GLBlendFunc
1427 {
1428   constexpr explicit GLBlendFunc(Graphics::BlendFactor factor)
1429   {
1430     switch(factor)
1431     {
1432       case Graphics::BlendFactor::ZERO:
1433       {
1434         glFactor = GL_ZERO;
1435         break;
1436       }
1437       case Graphics::BlendFactor::ONE:
1438       {
1439         glFactor = GL_ONE;
1440         break;
1441       }
1442       case Graphics::BlendFactor::SRC_COLOR:
1443       {
1444         glFactor = GL_SRC_COLOR;
1445         break;
1446       }
1447       case Graphics::BlendFactor::ONE_MINUS_SRC_COLOR:
1448       {
1449         glFactor = GL_ONE_MINUS_SRC_COLOR;
1450         break;
1451       }
1452       case Graphics::BlendFactor::DST_COLOR:
1453       {
1454         glFactor = GL_DST_COLOR;
1455         break;
1456       }
1457       case Graphics::BlendFactor::ONE_MINUS_DST_COLOR:
1458       {
1459         glFactor = GL_ONE_MINUS_DST_COLOR;
1460         break;
1461       }
1462       case Graphics::BlendFactor::SRC_ALPHA:
1463       {
1464         glFactor = GL_SRC_ALPHA;
1465         break;
1466       }
1467       case Graphics::BlendFactor::ONE_MINUS_SRC_ALPHA:
1468       {
1469         glFactor = GL_ONE_MINUS_SRC_ALPHA;
1470         break;
1471       }
1472       case Graphics::BlendFactor::DST_ALPHA:
1473       {
1474         glFactor = GL_DST_ALPHA;
1475         break;
1476       }
1477       case Graphics::BlendFactor::ONE_MINUS_DST_ALPHA:
1478       {
1479         glFactor = GL_ONE_MINUS_DST_ALPHA;
1480         break;
1481       }
1482       case Graphics::BlendFactor::CONSTANT_COLOR:
1483       {
1484         glFactor = GL_CONSTANT_COLOR;
1485         break;
1486       }
1487       case Graphics::BlendFactor::ONE_MINUS_CONSTANT_COLOR:
1488       {
1489         glFactor = GL_ONE_MINUS_CONSTANT_COLOR;
1490         break;
1491       }
1492       case Graphics::BlendFactor::CONSTANT_ALPHA:
1493       {
1494         glFactor = GL_CONSTANT_ALPHA;
1495         break;
1496       }
1497       case Graphics::BlendFactor::ONE_MINUS_CONSTANT_ALPHA:
1498       {
1499         glFactor = GL_ONE_MINUS_CONSTANT_ALPHA;
1500         break;
1501       }
1502       case Graphics::BlendFactor::SRC_ALPHA_SATURATE:
1503       {
1504         glFactor = GL_SRC_ALPHA_SATURATE;
1505         break;
1506       }
1507       // Below may be unsupported without extension
1508       case Graphics::BlendFactor::SRC1_COLOR:
1509       {
1510         glFactor = 0u;
1511         break;
1512       }
1513       case Graphics::BlendFactor::ONE_MINUS_SRC1_COLOR:
1514       {
1515         glFactor = 0u;
1516         break;
1517       }
1518       case Graphics::BlendFactor::SRC1_ALPHA:
1519       {
1520         glFactor = 0u;
1521         break;
1522       }
1523       case Graphics::BlendFactor::ONE_MINUS_SRC1_ALPHA:
1524       {
1525         glFactor = 0u;
1526         break;
1527       }
1528     }
1529   }
1530
1531   /**
1532    * @brief Explicit type conversion operator
1533    * @return converted value
1534    */
1535   constexpr inline operator GLenum() const
1536   {
1537     return glFactor;
1538   }
1539
1540   GLenum glFactor{0u};
1541 };
1542
1543 /**
1544  * @brief Converts Blend Op to GL
1545  */
1546 struct GLBlendOp
1547 {
1548   constexpr explicit GLBlendOp(Graphics::BlendOp blendOp)
1549   {
1550     switch(blendOp)
1551     {
1552       case Graphics::BlendOp::ADD:
1553       {
1554         glBlendOp = GL_FUNC_ADD;
1555         break;
1556       }
1557       case Graphics::BlendOp::SUBTRACT:
1558       {
1559         glBlendOp = GL_FUNC_SUBTRACT;
1560         break;
1561       }
1562       case Graphics::BlendOp::REVERSE_SUBTRACT:
1563       {
1564         glBlendOp = GL_FUNC_REVERSE_SUBTRACT;
1565         break;
1566       }
1567       case Graphics::BlendOp::MIN:
1568       {
1569         glBlendOp = GL_MIN;
1570         break;
1571       }
1572       case Graphics::BlendOp::MAX:
1573       {
1574         glBlendOp = GL_MAX;
1575         break;
1576       }
1577     }
1578   }
1579
1580   /**
1581    * @brief Explicit type conversion operator
1582    * @return converted value
1583    */
1584   constexpr inline operator GLenum() const
1585   {
1586     return glBlendOp;
1587   }
1588
1589   GLenum glBlendOp{0u};
1590 };
1591
1592 /**
1593  * @brief Converts GL cull mode
1594  */
1595 struct GLCullMode
1596 {
1597   constexpr explicit GLCullMode(Graphics::CullMode cullMode)
1598   {
1599     switch(cullMode)
1600     {
1601       case Graphics::CullMode::NONE: // this isn't really accepted by GL!
1602       {
1603         glCullMode = GL_NONE;
1604         break;
1605       }
1606       case Graphics::CullMode::FRONT:
1607       {
1608         glCullMode = GL_FRONT;
1609         break;
1610       }
1611       case Graphics::CullMode::BACK:
1612       {
1613         glCullMode = GL_BACK;
1614         break;
1615       }
1616       case Graphics::CullMode::FRONT_AND_BACK:
1617       {
1618         glCullMode = GL_FRONT_AND_BACK;
1619         break;
1620       }
1621     }
1622   }
1623
1624   /**
1625    * @brief Explicit type conversion operator
1626    * @return converted value
1627    */
1628   constexpr inline operator GLenum() const
1629   {
1630     return glCullMode;
1631   }
1632
1633   GLenum glCullMode{0u};
1634 };
1635
1636 } // namespace Dali::Graphics::GLES
1637
1638 #endif //DALI_GRAPHICS_API_TYPES_H