[ tor-browser ].git.dasho

load_functions_table_autogen.cpp (160944B)
      1 // GENERATED FILE - DO NOT EDIT.
      2 // Generated by gen_load_functions_table.py using data from load_functions_data.json
      3 //
      4 // Copyright 2020 The ANGLE Project Authors. All rights reserved.
      5 // Use of this source code is governed by a BSD-style license that can be
      6 // found in the LICENSE file.
      7 //
      8 // load_functions_table:
      9 //   Contains the GetLoadFunctionsMap for texture_format_util.h
     10 //
     11 
     12 #include "libANGLE/renderer/load_functions_table.h"
     13 
     14 #include "image_util/copyimage.h"
     15 #include "image_util/generatemip.h"
     16 #include "image_util/loadimage.h"
     17 
     18 using namespace rx;
     19 
     20 namespace angle
     21 {
     22 
     23 namespace
     24 {
     25 
     26 // ES3 image loading functions vary based on:
     27 //    - the GL internal format (supplied to glTex*Image*D)
     28 //    - the GL data type given (supplied to glTex*Image*D)
     29 //    - the target DXGI_FORMAT that the image will be loaded into (which is chosen based on the D3D
     30 //    device's capabilities)
     31 // This map type determines which loading function to use, based on these three parameters.
     32 // Source formats and types are taken from Tables 3.2 and 3.3 of the ES 3 spec.
     33 void UnimplementedLoadFunction(size_t width,
     34                               size_t height,
     35                               size_t depth,
     36                               const uint8_t *input,
     37                               size_t inputRowPitch,
     38                               size_t inputDepthPitch,
     39                               uint8_t *output,
     40                               size_t outputRowPitch,
     41                               size_t outputDepthPitch)
     42 {
     43    UNIMPLEMENTED();
     44 }
     45 
     46 void UnreachableLoadFunction(size_t width,
     47                             size_t height,
     48                             size_t depth,
     49                             const uint8_t *input,
     50                             size_t inputRowPitch,
     51                             size_t inputDepthPitch,
     52                             uint8_t *output,
     53                             size_t outputRowPitch,
     54                             size_t outputDepthPitch)
     55 {
     56    UNREACHABLE();
     57 }
     58 
     59 LoadImageFunctionInfo A1RGB5_ANGLEX_to_A1R5G5B5_UNORM(GLenum type)
     60 {
     61    switch (type)
     62    {
     63        case GL_UNSIGNED_BYTE:
     64            return LoadImageFunctionInfo(LoadRGB5A1ToRGBA8, true);
     65        case GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT:
     66            return LoadImageFunctionInfo(LoadToNative<GLushort, 1>, false);
     67        default:
     68            UNREACHABLE();
     69            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
     70    }
     71 }
     72 
     73 LoadImageFunctionInfo ALPHA_to_R16G16B16A16_FLOAT(GLenum type)
     74 {
     75    switch (type)
     76    {
     77        case GL_HALF_FLOAT:
     78            return LoadImageFunctionInfo(LoadA16FToRGBA16F, true);
     79        case GL_HALF_FLOAT_OES:
     80            return LoadImageFunctionInfo(LoadA16FToRGBA16F, true);
     81        case GL_UNSIGNED_BYTE:
     82            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
     83        default:
     84            UNREACHABLE();
     85            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
     86    }
     87 }
     88 
     89 LoadImageFunctionInfo ALPHA_to_R32G32B32A32_FLOAT(GLenum type)
     90 {
     91    switch (type)
     92    {
     93        case GL_FLOAT:
     94            return LoadImageFunctionInfo(LoadA32FToRGBA32F, true);
     95        case GL_UNSIGNED_BYTE:
     96            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
     97        default:
     98            UNREACHABLE();
     99            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    100    }
    101 }
    102 
    103 LoadImageFunctionInfo ALPHA_to_default(GLenum type)
    104 {
    105    switch (type)
    106    {
    107        case GL_UNSIGNED_BYTE:
    108            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    109        default:
    110            UNREACHABLE();
    111            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    112    }
    113 }
    114 
    115 LoadImageFunctionInfo ALPHA16F_EXT_to_R16_FLOAT(GLenum type)
    116 {
    117    switch (type)
    118    {
    119        case GL_HALF_FLOAT:
    120            return LoadImageFunctionInfo(LoadToNative<GLhalf, 1>, false);
    121        case GL_HALF_FLOAT_OES:
    122            return LoadImageFunctionInfo(LoadToNative<GLhalf, 1>, false);
    123        default:
    124            UNREACHABLE();
    125            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    126    }
    127 }
    128 
    129 LoadImageFunctionInfo ALPHA16F_EXT_to_default(GLenum type)
    130 {
    131    switch (type)
    132    {
    133        case GL_HALF_FLOAT:
    134            return LoadImageFunctionInfo(LoadA16FToRGBA16F, true);
    135        case GL_HALF_FLOAT_OES:
    136            return LoadImageFunctionInfo(LoadA16FToRGBA16F, true);
    137        default:
    138            UNREACHABLE();
    139            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    140    }
    141 }
    142 
    143 LoadImageFunctionInfo ALPHA32F_EXT_to_R32_FLOAT(GLenum type)
    144 {
    145    switch (type)
    146    {
    147        case GL_FLOAT:
    148            return LoadImageFunctionInfo(LoadToNative<GLfloat, 1>, false);
    149        default:
    150            UNREACHABLE();
    151            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    152    }
    153 }
    154 
    155 LoadImageFunctionInfo ALPHA32F_EXT_to_default(GLenum type)
    156 {
    157    switch (type)
    158    {
    159        case GL_FLOAT:
    160            return LoadImageFunctionInfo(LoadA32FToRGBA32F, true);
    161        default:
    162            UNREACHABLE();
    163            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    164    }
    165 }
    166 
    167 LoadImageFunctionInfo ALPHA8_EXT_to_A8_UNORM(GLenum type)
    168 {
    169    switch (type)
    170    {
    171        case GL_UNSIGNED_BYTE:
    172            return LoadImageFunctionInfo(LoadToNative<GLubyte, 1>, false);
    173        default:
    174            UNREACHABLE();
    175            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    176    }
    177 }
    178 
    179 LoadImageFunctionInfo ALPHA8_EXT_to_R8G8B8A8_UNORM(GLenum type)
    180 {
    181    switch (type)
    182    {
    183        case GL_UNSIGNED_BYTE:
    184            return LoadImageFunctionInfo(LoadA8ToRGBA8, true);
    185        default:
    186            UNREACHABLE();
    187            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    188    }
    189 }
    190 
    191 LoadImageFunctionInfo ALPHA8_EXT_to_R8_UNORM(GLenum type)
    192 {
    193    switch (type)
    194    {
    195        case GL_UNSIGNED_BYTE:
    196            return LoadImageFunctionInfo(LoadToNative<GLubyte, 1>, false);
    197        default:
    198            UNREACHABLE();
    199            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    200    }
    201 }
    202 
    203 LoadImageFunctionInfo BGR10_A2_ANGLEX_to_B10G10R10A2_UNORM(GLenum type)
    204 {
    205    switch (type)
    206    {
    207        case GL_UNSIGNED_INT_2_10_10_10_REV:
    208            return LoadImageFunctionInfo(LoadToNative<GLuint, 1>, false);
    209        default:
    210            UNREACHABLE();
    211            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    212    }
    213 }
    214 
    215 LoadImageFunctionInfo BGR565_ANGLEX_to_B5G6R5_UNORM(GLenum type)
    216 {
    217    switch (type)
    218    {
    219        case GL_UNSIGNED_BYTE:
    220            return LoadImageFunctionInfo(LoadRGB8ToBGR565, true);
    221        case GL_UNSIGNED_SHORT_5_6_5:
    222            return LoadImageFunctionInfo(LoadRGB565ToBGR565, true);
    223        default:
    224            UNREACHABLE();
    225            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    226    }
    227 }
    228 
    229 LoadImageFunctionInfo BGR5_A1_ANGLEX_to_default(GLenum type)
    230 {
    231    switch (type)
    232    {
    233        case GL_UNSIGNED_BYTE:
    234            return LoadImageFunctionInfo(LoadRGB5A1ToRGBA8, true);
    235        case GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT:
    236            return LoadImageFunctionInfo(LoadToNative<GLushort, 1>, false);
    237        default:
    238            UNREACHABLE();
    239            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    240    }
    241 }
    242 
    243 LoadImageFunctionInfo BGRA4_ANGLEX_to_default(GLenum type)
    244 {
    245    switch (type)
    246    {
    247        case GL_UNSIGNED_BYTE:
    248            return LoadImageFunctionInfo(LoadToNative<GLubyte, 4>, false);
    249        case GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT:
    250            return LoadImageFunctionInfo(LoadRGBA4ToRGBA8, true);
    251        default:
    252            UNREACHABLE();
    253            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    254    }
    255 }
    256 
    257 LoadImageFunctionInfo BGRA8_EXT_to_default(GLenum type)
    258 {
    259    switch (type)
    260    {
    261        case GL_UNSIGNED_BYTE:
    262            return LoadImageFunctionInfo(LoadToNative<GLubyte, 4>, false);
    263        default:
    264            UNREACHABLE();
    265            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    266    }
    267 }
    268 
    269 LoadImageFunctionInfo BGRA8_SRGB_ANGLEX_to_B8G8R8A8_UNORM_SRGB(GLenum type)
    270 {
    271    switch (type)
    272    {
    273        case GL_UNSIGNED_BYTE:
    274            return LoadImageFunctionInfo(LoadToNative<GLubyte, 4>, false);
    275        default:
    276            UNREACHABLE();
    277            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    278    }
    279 }
    280 
    281 LoadImageFunctionInfo BGRA_EXT_to_default(GLenum type)
    282 {
    283    switch (type)
    284    {
    285        case GL_UNSIGNED_BYTE:
    286            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    287        default:
    288            UNREACHABLE();
    289            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    290    }
    291 }
    292 
    293 LoadImageFunctionInfo BGRX8_ANGLEX_to_B8G8R8A8_UNORM(GLenum type)
    294 {
    295    switch (type)
    296    {
    297        case GL_UNSIGNED_BYTE:
    298            return LoadImageFunctionInfo(LoadToNative<GLubyte, 4>, false);
    299        default:
    300            UNREACHABLE();
    301            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    302    }
    303 }
    304 
    305 LoadImageFunctionInfo BGRX8_ANGLEX_to_B8G8R8X8_UNORM(GLenum type)
    306 {
    307    switch (type)
    308    {
    309        case GL_UNSIGNED_BYTE:
    310            return LoadImageFunctionInfo(LoadToNative<GLubyte, 4>, false);
    311        default:
    312            UNREACHABLE();
    313            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    314    }
    315 }
    316 
    317 LoadImageFunctionInfo COMPRESSED_R11_EAC_to_EAC_R11_UNORM_BLOCK(GLenum type)
    318 {
    319    switch (type)
    320    {
    321        case GL_UNSIGNED_BYTE:
    322            return LoadImageFunctionInfo(LoadCompressedToNative<4, 4, 1, 8>, true);
    323        default:
    324            UNREACHABLE();
    325            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    326    }
    327 }
    328 
    329 LoadImageFunctionInfo COMPRESSED_R11_EAC_to_R16_FLOAT(GLenum type)
    330 {
    331    switch (type)
    332    {
    333        case GL_UNSIGNED_BYTE:
    334            return LoadImageFunctionInfo(LoadEACR11ToR16F, true);
    335        default:
    336            UNREACHABLE();
    337            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    338    }
    339 }
    340 
    341 LoadImageFunctionInfo COMPRESSED_R11_EAC_to_R16_UNORM(GLenum type)
    342 {
    343    switch (type)
    344    {
    345        case GL_UNSIGNED_BYTE:
    346            return LoadImageFunctionInfo(LoadEACR11ToR16, true);
    347        default:
    348            UNREACHABLE();
    349            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    350    }
    351 }
    352 
    353 LoadImageFunctionInfo COMPRESSED_RED_GREEN_RGTC2_EXT_to_default(GLenum type)
    354 {
    355    switch (type)
    356    {
    357        case GL_UNSIGNED_BYTE:
    358            return LoadImageFunctionInfo(LoadCompressedToNative<4, 4, 1, 16>, true);
    359        default:
    360            UNREACHABLE();
    361            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    362    }
    363 }
    364 
    365 LoadImageFunctionInfo COMPRESSED_RED_RGTC1_EXT_to_default(GLenum type)
    366 {
    367    switch (type)
    368    {
    369        case GL_UNSIGNED_BYTE:
    370            return LoadImageFunctionInfo(LoadCompressedToNative<4, 4, 1, 8>, true);
    371        default:
    372            UNREACHABLE();
    373            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    374    }
    375 }
    376 
    377 LoadImageFunctionInfo COMPRESSED_RG11_EAC_to_EAC_R11G11_UNORM_BLOCK(GLenum type)
    378 {
    379    switch (type)
    380    {
    381        case GL_UNSIGNED_BYTE:
    382            return LoadImageFunctionInfo(LoadCompressedToNative<4, 4, 1, 16>, true);
    383        default:
    384            UNREACHABLE();
    385            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    386    }
    387 }
    388 
    389 LoadImageFunctionInfo COMPRESSED_RG11_EAC_to_R16G16_FLOAT(GLenum type)
    390 {
    391    switch (type)
    392    {
    393        case GL_UNSIGNED_BYTE:
    394            return LoadImageFunctionInfo(LoadEACRG11ToRG16F, true);
    395        default:
    396            UNREACHABLE();
    397            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    398    }
    399 }
    400 
    401 LoadImageFunctionInfo COMPRESSED_RG11_EAC_to_R16G16_UNORM(GLenum type)
    402 {
    403    switch (type)
    404    {
    405        case GL_UNSIGNED_BYTE:
    406            return LoadImageFunctionInfo(LoadEACRG11ToRG16, true);
    407        default:
    408            UNREACHABLE();
    409            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    410    }
    411 }
    412 
    413 LoadImageFunctionInfo COMPRESSED_RGB8_ETC2_to_ETC2_R8G8B8_UNORM_BLOCK(GLenum type)
    414 {
    415    switch (type)
    416    {
    417        case GL_UNSIGNED_BYTE:
    418            return LoadImageFunctionInfo(LoadCompressedToNative<4, 4, 1, 8>, true);
    419        default:
    420            UNREACHABLE();
    421            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    422    }
    423 }
    424 
    425 LoadImageFunctionInfo COMPRESSED_RGB8_ETC2_to_R8G8B8A8_UNORM(GLenum type)
    426 {
    427    switch (type)
    428    {
    429        case GL_UNSIGNED_BYTE:
    430            return LoadImageFunctionInfo(LoadETC2RGB8ToRGBA8, true);
    431        default:
    432            UNREACHABLE();
    433            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    434    }
    435 }
    436 
    437 LoadImageFunctionInfo COMPRESSED_RGB8_LOSSY_DECODE_ETC2_ANGLE_to_BC1_RGB_UNORM_BLOCK(GLenum type)
    438 {
    439    switch (type)
    440    {
    441        case GL_UNSIGNED_BYTE:
    442            return LoadImageFunctionInfo(LoadETC2RGB8ToBC1, true);
    443        default:
    444            UNREACHABLE();
    445            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    446    }
    447 }
    448 
    449 LoadImageFunctionInfo COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2_to_ETC2_R8G8B8A1_UNORM_BLOCK(
    450    GLenum type)
    451 {
    452    switch (type)
    453    {
    454        case GL_UNSIGNED_BYTE:
    455            return LoadImageFunctionInfo(LoadCompressedToNative<4, 4, 1, 8>, true);
    456        default:
    457            UNREACHABLE();
    458            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    459    }
    460 }
    461 
    462 LoadImageFunctionInfo COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2_to_R8G8B8A8_UNORM(GLenum type)
    463 {
    464    switch (type)
    465    {
    466        case GL_UNSIGNED_BYTE:
    467            return LoadImageFunctionInfo(LoadETC2RGB8A1ToRGBA8, true);
    468        default:
    469            UNREACHABLE();
    470            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    471    }
    472 }
    473 
    474 LoadImageFunctionInfo
    475 COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_LOSSY_DECODE_ETC2_ANGLE_to_BC1_RGBA_UNORM_BLOCK(GLenum type)
    476 {
    477    switch (type)
    478    {
    479        case GL_UNSIGNED_BYTE:
    480            return LoadImageFunctionInfo(LoadETC2RGB8A1ToBC1, true);
    481        default:
    482            UNREACHABLE();
    483            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    484    }
    485 }
    486 
    487 LoadImageFunctionInfo COMPRESSED_RGBA8_ETC2_EAC_to_ETC2_R8G8B8A8_UNORM_BLOCK(GLenum type)
    488 {
    489    switch (type)
    490    {
    491        case GL_UNSIGNED_BYTE:
    492            return LoadImageFunctionInfo(LoadCompressedToNative<4, 4, 1, 16>, true);
    493        default:
    494            UNREACHABLE();
    495            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    496    }
    497 }
    498 
    499 LoadImageFunctionInfo COMPRESSED_RGBA8_ETC2_EAC_to_R8G8B8A8_UNORM(GLenum type)
    500 {
    501    switch (type)
    502    {
    503        case GL_UNSIGNED_BYTE:
    504            return LoadImageFunctionInfo(LoadETC2RGBA8ToRGBA8, true);
    505        default:
    506            UNREACHABLE();
    507            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    508    }
    509 }
    510 
    511 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_10x10_KHR_to_R8G8B8A8_UNORM(GLenum type)
    512 {
    513    switch (type)
    514    {
    515        case GL_UNSIGNED_BYTE:
    516            return LoadImageFunctionInfo(LoadASTCToRGBA8<10, 10>, true);
    517        default:
    518            UNREACHABLE();
    519            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    520    }
    521 }
    522 
    523 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_10x10_KHR_to_default(GLenum type)
    524 {
    525    switch (type)
    526    {
    527        case GL_UNSIGNED_BYTE:
    528            return LoadImageFunctionInfo(LoadCompressedToNative<10, 10, 1, 16>, true);
    529        default:
    530            UNREACHABLE();
    531            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    532    }
    533 }
    534 
    535 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_10x5_KHR_to_R8G8B8A8_UNORM(GLenum type)
    536 {
    537    switch (type)
    538    {
    539        case GL_UNSIGNED_BYTE:
    540            return LoadImageFunctionInfo(LoadASTCToRGBA8<10, 5>, true);
    541        default:
    542            UNREACHABLE();
    543            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    544    }
    545 }
    546 
    547 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_10x5_KHR_to_default(GLenum type)
    548 {
    549    switch (type)
    550    {
    551        case GL_UNSIGNED_BYTE:
    552            return LoadImageFunctionInfo(LoadCompressedToNative<10, 5, 1, 16>, true);
    553        default:
    554            UNREACHABLE();
    555            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    556    }
    557 }
    558 
    559 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_10x6_KHR_to_R8G8B8A8_UNORM(GLenum type)
    560 {
    561    switch (type)
    562    {
    563        case GL_UNSIGNED_BYTE:
    564            return LoadImageFunctionInfo(LoadASTCToRGBA8<10, 6>, true);
    565        default:
    566            UNREACHABLE();
    567            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    568    }
    569 }
    570 
    571 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_10x6_KHR_to_default(GLenum type)
    572 {
    573    switch (type)
    574    {
    575        case GL_UNSIGNED_BYTE:
    576            return LoadImageFunctionInfo(LoadCompressedToNative<10, 6, 1, 16>, true);
    577        default:
    578            UNREACHABLE();
    579            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    580    }
    581 }
    582 
    583 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_10x8_KHR_to_R8G8B8A8_UNORM(GLenum type)
    584 {
    585    switch (type)
    586    {
    587        case GL_UNSIGNED_BYTE:
    588            return LoadImageFunctionInfo(LoadASTCToRGBA8<10, 8>, true);
    589        default:
    590            UNREACHABLE();
    591            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    592    }
    593 }
    594 
    595 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_10x8_KHR_to_default(GLenum type)
    596 {
    597    switch (type)
    598    {
    599        case GL_UNSIGNED_BYTE:
    600            return LoadImageFunctionInfo(LoadCompressedToNative<10, 8, 1, 16>, true);
    601        default:
    602            UNREACHABLE();
    603            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    604    }
    605 }
    606 
    607 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_12x10_KHR_to_R8G8B8A8_UNORM(GLenum type)
    608 {
    609    switch (type)
    610    {
    611        case GL_UNSIGNED_BYTE:
    612            return LoadImageFunctionInfo(LoadASTCToRGBA8<12, 10>, true);
    613        default:
    614            UNREACHABLE();
    615            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    616    }
    617 }
    618 
    619 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_12x10_KHR_to_default(GLenum type)
    620 {
    621    switch (type)
    622    {
    623        case GL_UNSIGNED_BYTE:
    624            return LoadImageFunctionInfo(LoadCompressedToNative<12, 10, 1, 16>, true);
    625        default:
    626            UNREACHABLE();
    627            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    628    }
    629 }
    630 
    631 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_12x12_KHR_to_R8G8B8A8_UNORM(GLenum type)
    632 {
    633    switch (type)
    634    {
    635        case GL_UNSIGNED_BYTE:
    636            return LoadImageFunctionInfo(LoadASTCToRGBA8<12, 12>, true);
    637        default:
    638            UNREACHABLE();
    639            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    640    }
    641 }
    642 
    643 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_12x12_KHR_to_default(GLenum type)
    644 {
    645    switch (type)
    646    {
    647        case GL_UNSIGNED_BYTE:
    648            return LoadImageFunctionInfo(LoadCompressedToNative<12, 12, 1, 16>, true);
    649        default:
    650            UNREACHABLE();
    651            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    652    }
    653 }
    654 
    655 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_3x3x3_OES_to_default(GLenum type)
    656 {
    657    switch (type)
    658    {
    659        case GL_UNSIGNED_BYTE:
    660            return LoadImageFunctionInfo(LoadCompressedToNative<3, 3, 3, 16>, true);
    661        default:
    662            UNREACHABLE();
    663            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    664    }
    665 }
    666 
    667 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_4x3x3_OES_to_default(GLenum type)
    668 {
    669    switch (type)
    670    {
    671        case GL_UNSIGNED_BYTE:
    672            return LoadImageFunctionInfo(LoadCompressedToNative<4, 3, 3, 16>, true);
    673        default:
    674            UNREACHABLE();
    675            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    676    }
    677 }
    678 
    679 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_4x4_KHR_to_R8G8B8A8_UNORM(GLenum type)
    680 {
    681    switch (type)
    682    {
    683        case GL_UNSIGNED_BYTE:
    684            return LoadImageFunctionInfo(LoadASTCToRGBA8<4, 4>, true);
    685        default:
    686            UNREACHABLE();
    687            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    688    }
    689 }
    690 
    691 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_4x4_KHR_to_default(GLenum type)
    692 {
    693    switch (type)
    694    {
    695        case GL_UNSIGNED_BYTE:
    696            return LoadImageFunctionInfo(LoadCompressedToNative<4, 4, 1, 16>, true);
    697        default:
    698            UNREACHABLE();
    699            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    700    }
    701 }
    702 
    703 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_4x4x3_OES_to_default(GLenum type)
    704 {
    705    switch (type)
    706    {
    707        case GL_UNSIGNED_BYTE:
    708            return LoadImageFunctionInfo(LoadCompressedToNative<4, 4, 3, 16>, true);
    709        default:
    710            UNREACHABLE();
    711            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    712    }
    713 }
    714 
    715 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_4x4x4_OES_to_default(GLenum type)
    716 {
    717    switch (type)
    718    {
    719        case GL_UNSIGNED_BYTE:
    720            return LoadImageFunctionInfo(LoadCompressedToNative<4, 4, 4, 16>, true);
    721        default:
    722            UNREACHABLE();
    723            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    724    }
    725 }
    726 
    727 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_5x4_KHR_to_R8G8B8A8_UNORM(GLenum type)
    728 {
    729    switch (type)
    730    {
    731        case GL_UNSIGNED_BYTE:
    732            return LoadImageFunctionInfo(LoadASTCToRGBA8<5, 4>, true);
    733        default:
    734            UNREACHABLE();
    735            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    736    }
    737 }
    738 
    739 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_5x4_KHR_to_default(GLenum type)
    740 {
    741    switch (type)
    742    {
    743        case GL_UNSIGNED_BYTE:
    744            return LoadImageFunctionInfo(LoadCompressedToNative<5, 4, 1, 16>, true);
    745        default:
    746            UNREACHABLE();
    747            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    748    }
    749 }
    750 
    751 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_5x4x4_OES_to_default(GLenum type)
    752 {
    753    switch (type)
    754    {
    755        case GL_UNSIGNED_BYTE:
    756            return LoadImageFunctionInfo(LoadCompressedToNative<5, 4, 4, 16>, true);
    757        default:
    758            UNREACHABLE();
    759            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    760    }
    761 }
    762 
    763 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_5x5_KHR_to_R8G8B8A8_UNORM(GLenum type)
    764 {
    765    switch (type)
    766    {
    767        case GL_UNSIGNED_BYTE:
    768            return LoadImageFunctionInfo(LoadASTCToRGBA8<5, 5>, true);
    769        default:
    770            UNREACHABLE();
    771            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    772    }
    773 }
    774 
    775 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_5x5_KHR_to_default(GLenum type)
    776 {
    777    switch (type)
    778    {
    779        case GL_UNSIGNED_BYTE:
    780            return LoadImageFunctionInfo(LoadCompressedToNative<5, 5, 1, 16>, true);
    781        default:
    782            UNREACHABLE();
    783            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    784    }
    785 }
    786 
    787 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_5x5x4_OES_to_default(GLenum type)
    788 {
    789    switch (type)
    790    {
    791        case GL_UNSIGNED_BYTE:
    792            return LoadImageFunctionInfo(LoadCompressedToNative<5, 5, 4, 16>, true);
    793        default:
    794            UNREACHABLE();
    795            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    796    }
    797 }
    798 
    799 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_5x5x5_OES_to_default(GLenum type)
    800 {
    801    switch (type)
    802    {
    803        case GL_UNSIGNED_BYTE:
    804            return LoadImageFunctionInfo(LoadCompressedToNative<5, 5, 5, 16>, true);
    805        default:
    806            UNREACHABLE();
    807            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    808    }
    809 }
    810 
    811 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_6x5_KHR_to_R8G8B8A8_UNORM(GLenum type)
    812 {
    813    switch (type)
    814    {
    815        case GL_UNSIGNED_BYTE:
    816            return LoadImageFunctionInfo(LoadASTCToRGBA8<6, 5>, true);
    817        default:
    818            UNREACHABLE();
    819            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    820    }
    821 }
    822 
    823 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_6x5_KHR_to_default(GLenum type)
    824 {
    825    switch (type)
    826    {
    827        case GL_UNSIGNED_BYTE:
    828            return LoadImageFunctionInfo(LoadCompressedToNative<6, 5, 1, 16>, true);
    829        default:
    830            UNREACHABLE();
    831            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    832    }
    833 }
    834 
    835 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_6x5x5_OES_to_default(GLenum type)
    836 {
    837    switch (type)
    838    {
    839        case GL_UNSIGNED_BYTE:
    840            return LoadImageFunctionInfo(LoadCompressedToNative<6, 5, 5, 16>, true);
    841        default:
    842            UNREACHABLE();
    843            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    844    }
    845 }
    846 
    847 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_6x6_KHR_to_R8G8B8A8_UNORM(GLenum type)
    848 {
    849    switch (type)
    850    {
    851        case GL_UNSIGNED_BYTE:
    852            return LoadImageFunctionInfo(LoadASTCToRGBA8<6, 6>, true);
    853        default:
    854            UNREACHABLE();
    855            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    856    }
    857 }
    858 
    859 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_6x6_KHR_to_default(GLenum type)
    860 {
    861    switch (type)
    862    {
    863        case GL_UNSIGNED_BYTE:
    864            return LoadImageFunctionInfo(LoadCompressedToNative<6, 6, 1, 16>, true);
    865        default:
    866            UNREACHABLE();
    867            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    868    }
    869 }
    870 
    871 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_6x6x5_OES_to_default(GLenum type)
    872 {
    873    switch (type)
    874    {
    875        case GL_UNSIGNED_BYTE:
    876            return LoadImageFunctionInfo(LoadCompressedToNative<6, 6, 5, 16>, true);
    877        default:
    878            UNREACHABLE();
    879            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    880    }
    881 }
    882 
    883 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_6x6x6_OES_to_default(GLenum type)
    884 {
    885    switch (type)
    886    {
    887        case GL_UNSIGNED_BYTE:
    888            return LoadImageFunctionInfo(LoadCompressedToNative<6, 6, 6, 16>, true);
    889        default:
    890            UNREACHABLE();
    891            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    892    }
    893 }
    894 
    895 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_8x5_KHR_to_R8G8B8A8_UNORM(GLenum type)
    896 {
    897    switch (type)
    898    {
    899        case GL_UNSIGNED_BYTE:
    900            return LoadImageFunctionInfo(LoadASTCToRGBA8<8, 5>, true);
    901        default:
    902            UNREACHABLE();
    903            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    904    }
    905 }
    906 
    907 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_8x5_KHR_to_default(GLenum type)
    908 {
    909    switch (type)
    910    {
    911        case GL_UNSIGNED_BYTE:
    912            return LoadImageFunctionInfo(LoadCompressedToNative<8, 5, 1, 16>, true);
    913        default:
    914            UNREACHABLE();
    915            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    916    }
    917 }
    918 
    919 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_8x6_KHR_to_R8G8B8A8_UNORM(GLenum type)
    920 {
    921    switch (type)
    922    {
    923        case GL_UNSIGNED_BYTE:
    924            return LoadImageFunctionInfo(LoadASTCToRGBA8<8, 6>, true);
    925        default:
    926            UNREACHABLE();
    927            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    928    }
    929 }
    930 
    931 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_8x6_KHR_to_default(GLenum type)
    932 {
    933    switch (type)
    934    {
    935        case GL_UNSIGNED_BYTE:
    936            return LoadImageFunctionInfo(LoadCompressedToNative<8, 6, 1, 16>, true);
    937        default:
    938            UNREACHABLE();
    939            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    940    }
    941 }
    942 
    943 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_8x8_KHR_to_R8G8B8A8_UNORM(GLenum type)
    944 {
    945    switch (type)
    946    {
    947        case GL_UNSIGNED_BYTE:
    948            return LoadImageFunctionInfo(LoadASTCToRGBA8<8, 8>, true);
    949        default:
    950            UNREACHABLE();
    951            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    952    }
    953 }
    954 
    955 LoadImageFunctionInfo COMPRESSED_RGBA_ASTC_8x8_KHR_to_default(GLenum type)
    956 {
    957    switch (type)
    958    {
    959        case GL_UNSIGNED_BYTE:
    960            return LoadImageFunctionInfo(LoadCompressedToNative<8, 8, 1, 16>, true);
    961        default:
    962            UNREACHABLE();
    963            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    964    }
    965 }
    966 
    967 LoadImageFunctionInfo COMPRESSED_RGBA_BPTC_UNORM_EXT_to_default(GLenum type)
    968 {
    969    switch (type)
    970    {
    971        case GL_UNSIGNED_BYTE:
    972            return LoadImageFunctionInfo(LoadCompressedToNative<4, 4, 1, 16>, true);
    973        default:
    974            UNREACHABLE();
    975            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    976    }
    977 }
    978 
    979 LoadImageFunctionInfo COMPRESSED_RGBA_S3TC_DXT1_EXT_to_default(GLenum type)
    980 {
    981    switch (type)
    982    {
    983        case GL_UNSIGNED_BYTE:
    984            return LoadImageFunctionInfo(LoadCompressedToNative<4, 4, 1, 8>, true);
    985        default:
    986            UNREACHABLE();
    987            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
    988    }
    989 }
    990 
    991 LoadImageFunctionInfo COMPRESSED_RGBA_S3TC_DXT3_ANGLE_to_default(GLenum type)
    992 {
    993    switch (type)
    994    {
    995        case GL_UNSIGNED_BYTE:
    996            return LoadImageFunctionInfo(LoadCompressedToNative<4, 4, 1, 16>, true);
    997        default:
    998            UNREACHABLE();
    999            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1000    }
   1001 }
   1002 
   1003 LoadImageFunctionInfo COMPRESSED_RGBA_S3TC_DXT5_ANGLE_to_default(GLenum type)
   1004 {
   1005    switch (type)
   1006    {
   1007        case GL_UNSIGNED_BYTE:
   1008            return LoadImageFunctionInfo(LoadCompressedToNative<4, 4, 1, 16>, true);
   1009        default:
   1010            UNREACHABLE();
   1011            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1012    }
   1013 }
   1014 
   1015 LoadImageFunctionInfo COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT_to_default(GLenum type)
   1016 {
   1017    switch (type)
   1018    {
   1019        case GL_UNSIGNED_BYTE:
   1020            return LoadImageFunctionInfo(LoadCompressedToNative<4, 4, 1, 16>, true);
   1021        default:
   1022            UNREACHABLE();
   1023            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1024    }
   1025 }
   1026 
   1027 LoadImageFunctionInfo COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT_to_default(GLenum type)
   1028 {
   1029    switch (type)
   1030    {
   1031        case GL_UNSIGNED_BYTE:
   1032            return LoadImageFunctionInfo(LoadCompressedToNative<4, 4, 1, 16>, true);
   1033        default:
   1034            UNREACHABLE();
   1035            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1036    }
   1037 }
   1038 
   1039 LoadImageFunctionInfo COMPRESSED_RGB_S3TC_DXT1_EXT_to_default(GLenum type)
   1040 {
   1041    switch (type)
   1042    {
   1043        case GL_UNSIGNED_BYTE:
   1044            return LoadImageFunctionInfo(LoadCompressedToNative<4, 4, 1, 8>, true);
   1045        default:
   1046            UNREACHABLE();
   1047            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1048    }
   1049 }
   1050 
   1051 LoadImageFunctionInfo COMPRESSED_SIGNED_R11_EAC_to_EAC_R11_SNORM_BLOCK(GLenum type)
   1052 {
   1053    switch (type)
   1054    {
   1055        case GL_UNSIGNED_BYTE:
   1056            return LoadImageFunctionInfo(LoadCompressedToNative<4, 4, 1, 8>, true);
   1057        default:
   1058            UNREACHABLE();
   1059            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1060    }
   1061 }
   1062 
   1063 LoadImageFunctionInfo COMPRESSED_SIGNED_R11_EAC_to_R16_FLOAT(GLenum type)
   1064 {
   1065    switch (type)
   1066    {
   1067        case GL_UNSIGNED_BYTE:
   1068            return LoadImageFunctionInfo(LoadEACR11SToR16F, true);
   1069        default:
   1070            UNREACHABLE();
   1071            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1072    }
   1073 }
   1074 
   1075 LoadImageFunctionInfo COMPRESSED_SIGNED_R11_EAC_to_R16_SNORM(GLenum type)
   1076 {
   1077    switch (type)
   1078    {
   1079        case GL_UNSIGNED_BYTE:
   1080            return LoadImageFunctionInfo(LoadEACR11SToR16, true);
   1081        default:
   1082            UNREACHABLE();
   1083            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1084    }
   1085 }
   1086 
   1087 LoadImageFunctionInfo COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT_to_default(GLenum type)
   1088 {
   1089    switch (type)
   1090    {
   1091        case GL_UNSIGNED_BYTE:
   1092            return LoadImageFunctionInfo(LoadCompressedToNative<4, 4, 1, 16>, true);
   1093        default:
   1094            UNREACHABLE();
   1095            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1096    }
   1097 }
   1098 
   1099 LoadImageFunctionInfo COMPRESSED_SIGNED_RED_RGTC1_EXT_to_default(GLenum type)
   1100 {
   1101    switch (type)
   1102    {
   1103        case GL_UNSIGNED_BYTE:
   1104            return LoadImageFunctionInfo(LoadCompressedToNative<4, 4, 1, 8>, true);
   1105        default:
   1106            UNREACHABLE();
   1107            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1108    }
   1109 }
   1110 
   1111 LoadImageFunctionInfo COMPRESSED_SIGNED_RG11_EAC_to_EAC_R11G11_SNORM_BLOCK(GLenum type)
   1112 {
   1113    switch (type)
   1114    {
   1115        case GL_UNSIGNED_BYTE:
   1116            return LoadImageFunctionInfo(LoadCompressedToNative<4, 4, 1, 16>, true);
   1117        default:
   1118            UNREACHABLE();
   1119            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1120    }
   1121 }
   1122 
   1123 LoadImageFunctionInfo COMPRESSED_SIGNED_RG11_EAC_to_R16G16_FLOAT(GLenum type)
   1124 {
   1125    switch (type)
   1126    {
   1127        case GL_UNSIGNED_BYTE:
   1128            return LoadImageFunctionInfo(LoadEACRG11SToRG16F, true);
   1129        default:
   1130            UNREACHABLE();
   1131            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1132    }
   1133 }
   1134 
   1135 LoadImageFunctionInfo COMPRESSED_SIGNED_RG11_EAC_to_R16G16_SNORM(GLenum type)
   1136 {
   1137    switch (type)
   1138    {
   1139        case GL_UNSIGNED_BYTE:
   1140            return LoadImageFunctionInfo(LoadEACRG11SToRG16, true);
   1141        default:
   1142            UNREACHABLE();
   1143            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1144    }
   1145 }
   1146 
   1147 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR_to_R8G8B8A8_UNORM_SRGB(GLenum type)
   1148 {
   1149    switch (type)
   1150    {
   1151        case GL_UNSIGNED_BYTE:
   1152            return LoadImageFunctionInfo(LoadASTCToRGBA8<10, 10>, true);
   1153        default:
   1154            UNREACHABLE();
   1155            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1156    }
   1157 }
   1158 
   1159 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR_to_default(GLenum type)
   1160 {
   1161    switch (type)
   1162    {
   1163        case GL_UNSIGNED_BYTE:
   1164            return LoadImageFunctionInfo(LoadCompressedToNative<10, 10, 1, 16>, true);
   1165        default:
   1166            UNREACHABLE();
   1167            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1168    }
   1169 }
   1170 
   1171 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR_to_R8G8B8A8_UNORM_SRGB(GLenum type)
   1172 {
   1173    switch (type)
   1174    {
   1175        case GL_UNSIGNED_BYTE:
   1176            return LoadImageFunctionInfo(LoadASTCToRGBA8<10, 5>, true);
   1177        default:
   1178            UNREACHABLE();
   1179            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1180    }
   1181 }
   1182 
   1183 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR_to_default(GLenum type)
   1184 {
   1185    switch (type)
   1186    {
   1187        case GL_UNSIGNED_BYTE:
   1188            return LoadImageFunctionInfo(LoadCompressedToNative<10, 5, 1, 16>, true);
   1189        default:
   1190            UNREACHABLE();
   1191            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1192    }
   1193 }
   1194 
   1195 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR_to_R8G8B8A8_UNORM_SRGB(GLenum type)
   1196 {
   1197    switch (type)
   1198    {
   1199        case GL_UNSIGNED_BYTE:
   1200            return LoadImageFunctionInfo(LoadASTCToRGBA8<10, 6>, true);
   1201        default:
   1202            UNREACHABLE();
   1203            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1204    }
   1205 }
   1206 
   1207 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR_to_default(GLenum type)
   1208 {
   1209    switch (type)
   1210    {
   1211        case GL_UNSIGNED_BYTE:
   1212            return LoadImageFunctionInfo(LoadCompressedToNative<10, 6, 1, 16>, true);
   1213        default:
   1214            UNREACHABLE();
   1215            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1216    }
   1217 }
   1218 
   1219 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR_to_R8G8B8A8_UNORM_SRGB(GLenum type)
   1220 {
   1221    switch (type)
   1222    {
   1223        case GL_UNSIGNED_BYTE:
   1224            return LoadImageFunctionInfo(LoadASTCToRGBA8<10, 8>, true);
   1225        default:
   1226            UNREACHABLE();
   1227            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1228    }
   1229 }
   1230 
   1231 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR_to_default(GLenum type)
   1232 {
   1233    switch (type)
   1234    {
   1235        case GL_UNSIGNED_BYTE:
   1236            return LoadImageFunctionInfo(LoadCompressedToNative<10, 8, 1, 16>, true);
   1237        default:
   1238            UNREACHABLE();
   1239            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1240    }
   1241 }
   1242 
   1243 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR_to_R8G8B8A8_UNORM_SRGB(GLenum type)
   1244 {
   1245    switch (type)
   1246    {
   1247        case GL_UNSIGNED_BYTE:
   1248            return LoadImageFunctionInfo(LoadASTCToRGBA8<12, 10>, true);
   1249        default:
   1250            UNREACHABLE();
   1251            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1252    }
   1253 }
   1254 
   1255 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR_to_default(GLenum type)
   1256 {
   1257    switch (type)
   1258    {
   1259        case GL_UNSIGNED_BYTE:
   1260            return LoadImageFunctionInfo(LoadCompressedToNative<12, 10, 1, 16>, true);
   1261        default:
   1262            UNREACHABLE();
   1263            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1264    }
   1265 }
   1266 
   1267 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR_to_R8G8B8A8_UNORM_SRGB(GLenum type)
   1268 {
   1269    switch (type)
   1270    {
   1271        case GL_UNSIGNED_BYTE:
   1272            return LoadImageFunctionInfo(LoadASTCToRGBA8<12, 12>, true);
   1273        default:
   1274            UNREACHABLE();
   1275            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1276    }
   1277 }
   1278 
   1279 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR_to_default(GLenum type)
   1280 {
   1281    switch (type)
   1282    {
   1283        case GL_UNSIGNED_BYTE:
   1284            return LoadImageFunctionInfo(LoadCompressedToNative<12, 12, 1, 16>, true);
   1285        default:
   1286            UNREACHABLE();
   1287            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1288    }
   1289 }
   1290 
   1291 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES_to_default(GLenum type)
   1292 {
   1293    switch (type)
   1294    {
   1295        case GL_UNSIGNED_BYTE:
   1296            return LoadImageFunctionInfo(LoadCompressedToNative<3, 3, 3, 16>, true);
   1297        default:
   1298            UNREACHABLE();
   1299            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1300    }
   1301 }
   1302 
   1303 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES_to_default(GLenum type)
   1304 {
   1305    switch (type)
   1306    {
   1307        case GL_UNSIGNED_BYTE:
   1308            return LoadImageFunctionInfo(LoadCompressedToNative<4, 3, 3, 16>, true);
   1309        default:
   1310            UNREACHABLE();
   1311            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1312    }
   1313 }
   1314 
   1315 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR_to_R8G8B8A8_UNORM_SRGB(GLenum type)
   1316 {
   1317    switch (type)
   1318    {
   1319        case GL_UNSIGNED_BYTE:
   1320            return LoadImageFunctionInfo(LoadASTCToRGBA8<4, 4>, true);
   1321        default:
   1322            UNREACHABLE();
   1323            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1324    }
   1325 }
   1326 
   1327 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR_to_default(GLenum type)
   1328 {
   1329    switch (type)
   1330    {
   1331        case GL_UNSIGNED_BYTE:
   1332            return LoadImageFunctionInfo(LoadCompressedToNative<4, 4, 1, 16>, true);
   1333        default:
   1334            UNREACHABLE();
   1335            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1336    }
   1337 }
   1338 
   1339 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES_to_default(GLenum type)
   1340 {
   1341    switch (type)
   1342    {
   1343        case GL_UNSIGNED_BYTE:
   1344            return LoadImageFunctionInfo(LoadCompressedToNative<4, 4, 3, 16>, true);
   1345        default:
   1346            UNREACHABLE();
   1347            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1348    }
   1349 }
   1350 
   1351 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES_to_default(GLenum type)
   1352 {
   1353    switch (type)
   1354    {
   1355        case GL_UNSIGNED_BYTE:
   1356            return LoadImageFunctionInfo(LoadCompressedToNative<4, 4, 4, 16>, true);
   1357        default:
   1358            UNREACHABLE();
   1359            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1360    }
   1361 }
   1362 
   1363 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR_to_R8G8B8A8_UNORM_SRGB(GLenum type)
   1364 {
   1365    switch (type)
   1366    {
   1367        case GL_UNSIGNED_BYTE:
   1368            return LoadImageFunctionInfo(LoadASTCToRGBA8<5, 4>, true);
   1369        default:
   1370            UNREACHABLE();
   1371            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1372    }
   1373 }
   1374 
   1375 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR_to_default(GLenum type)
   1376 {
   1377    switch (type)
   1378    {
   1379        case GL_UNSIGNED_BYTE:
   1380            return LoadImageFunctionInfo(LoadCompressedToNative<5, 4, 1, 16>, true);
   1381        default:
   1382            UNREACHABLE();
   1383            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1384    }
   1385 }
   1386 
   1387 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES_to_default(GLenum type)
   1388 {
   1389    switch (type)
   1390    {
   1391        case GL_UNSIGNED_BYTE:
   1392            return LoadImageFunctionInfo(LoadCompressedToNative<5, 4, 4, 16>, true);
   1393        default:
   1394            UNREACHABLE();
   1395            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1396    }
   1397 }
   1398 
   1399 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR_to_R8G8B8A8_UNORM_SRGB(GLenum type)
   1400 {
   1401    switch (type)
   1402    {
   1403        case GL_UNSIGNED_BYTE:
   1404            return LoadImageFunctionInfo(LoadASTCToRGBA8<5, 5>, true);
   1405        default:
   1406            UNREACHABLE();
   1407            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1408    }
   1409 }
   1410 
   1411 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR_to_default(GLenum type)
   1412 {
   1413    switch (type)
   1414    {
   1415        case GL_UNSIGNED_BYTE:
   1416            return LoadImageFunctionInfo(LoadCompressedToNative<5, 5, 1, 16>, true);
   1417        default:
   1418            UNREACHABLE();
   1419            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1420    }
   1421 }
   1422 
   1423 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES_to_default(GLenum type)
   1424 {
   1425    switch (type)
   1426    {
   1427        case GL_UNSIGNED_BYTE:
   1428            return LoadImageFunctionInfo(LoadCompressedToNative<5, 5, 4, 16>, true);
   1429        default:
   1430            UNREACHABLE();
   1431            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1432    }
   1433 }
   1434 
   1435 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES_to_default(GLenum type)
   1436 {
   1437    switch (type)
   1438    {
   1439        case GL_UNSIGNED_BYTE:
   1440            return LoadImageFunctionInfo(LoadCompressedToNative<5, 5, 5, 16>, true);
   1441        default:
   1442            UNREACHABLE();
   1443            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1444    }
   1445 }
   1446 
   1447 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR_to_R8G8B8A8_UNORM_SRGB(GLenum type)
   1448 {
   1449    switch (type)
   1450    {
   1451        case GL_UNSIGNED_BYTE:
   1452            return LoadImageFunctionInfo(LoadASTCToRGBA8<6, 5>, true);
   1453        default:
   1454            UNREACHABLE();
   1455            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1456    }
   1457 }
   1458 
   1459 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR_to_default(GLenum type)
   1460 {
   1461    switch (type)
   1462    {
   1463        case GL_UNSIGNED_BYTE:
   1464            return LoadImageFunctionInfo(LoadCompressedToNative<6, 5, 1, 16>, true);
   1465        default:
   1466            UNREACHABLE();
   1467            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1468    }
   1469 }
   1470 
   1471 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES_to_default(GLenum type)
   1472 {
   1473    switch (type)
   1474    {
   1475        case GL_UNSIGNED_BYTE:
   1476            return LoadImageFunctionInfo(LoadCompressedToNative<6, 5, 5, 16>, true);
   1477        default:
   1478            UNREACHABLE();
   1479            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1480    }
   1481 }
   1482 
   1483 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR_to_R8G8B8A8_UNORM_SRGB(GLenum type)
   1484 {
   1485    switch (type)
   1486    {
   1487        case GL_UNSIGNED_BYTE:
   1488            return LoadImageFunctionInfo(LoadASTCToRGBA8<6, 6>, true);
   1489        default:
   1490            UNREACHABLE();
   1491            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1492    }
   1493 }
   1494 
   1495 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR_to_default(GLenum type)
   1496 {
   1497    switch (type)
   1498    {
   1499        case GL_UNSIGNED_BYTE:
   1500            return LoadImageFunctionInfo(LoadCompressedToNative<6, 6, 1, 16>, true);
   1501        default:
   1502            UNREACHABLE();
   1503            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1504    }
   1505 }
   1506 
   1507 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES_to_default(GLenum type)
   1508 {
   1509    switch (type)
   1510    {
   1511        case GL_UNSIGNED_BYTE:
   1512            return LoadImageFunctionInfo(LoadCompressedToNative<6, 6, 5, 16>, true);
   1513        default:
   1514            UNREACHABLE();
   1515            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1516    }
   1517 }
   1518 
   1519 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES_to_default(GLenum type)
   1520 {
   1521    switch (type)
   1522    {
   1523        case GL_UNSIGNED_BYTE:
   1524            return LoadImageFunctionInfo(LoadCompressedToNative<6, 6, 6, 16>, true);
   1525        default:
   1526            UNREACHABLE();
   1527            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1528    }
   1529 }
   1530 
   1531 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR_to_R8G8B8A8_UNORM_SRGB(GLenum type)
   1532 {
   1533    switch (type)
   1534    {
   1535        case GL_UNSIGNED_BYTE:
   1536            return LoadImageFunctionInfo(LoadASTCToRGBA8<8, 5>, true);
   1537        default:
   1538            UNREACHABLE();
   1539            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1540    }
   1541 }
   1542 
   1543 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR_to_default(GLenum type)
   1544 {
   1545    switch (type)
   1546    {
   1547        case GL_UNSIGNED_BYTE:
   1548            return LoadImageFunctionInfo(LoadCompressedToNative<8, 5, 1, 16>, true);
   1549        default:
   1550            UNREACHABLE();
   1551            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1552    }
   1553 }
   1554 
   1555 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR_to_R8G8B8A8_UNORM_SRGB(GLenum type)
   1556 {
   1557    switch (type)
   1558    {
   1559        case GL_UNSIGNED_BYTE:
   1560            return LoadImageFunctionInfo(LoadASTCToRGBA8<8, 6>, true);
   1561        default:
   1562            UNREACHABLE();
   1563            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1564    }
   1565 }
   1566 
   1567 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR_to_default(GLenum type)
   1568 {
   1569    switch (type)
   1570    {
   1571        case GL_UNSIGNED_BYTE:
   1572            return LoadImageFunctionInfo(LoadCompressedToNative<8, 6, 1, 16>, true);
   1573        default:
   1574            UNREACHABLE();
   1575            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1576    }
   1577 }
   1578 
   1579 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR_to_R8G8B8A8_UNORM_SRGB(GLenum type)
   1580 {
   1581    switch (type)
   1582    {
   1583        case GL_UNSIGNED_BYTE:
   1584            return LoadImageFunctionInfo(LoadASTCToRGBA8<8, 8>, true);
   1585        default:
   1586            UNREACHABLE();
   1587            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1588    }
   1589 }
   1590 
   1591 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR_to_default(GLenum type)
   1592 {
   1593    switch (type)
   1594    {
   1595        case GL_UNSIGNED_BYTE:
   1596            return LoadImageFunctionInfo(LoadCompressedToNative<8, 8, 1, 16>, true);
   1597        default:
   1598            UNREACHABLE();
   1599            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1600    }
   1601 }
   1602 
   1603 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ETC2_EAC_to_ETC2_R8G8B8A8_SRGB_BLOCK(GLenum type)
   1604 {
   1605    switch (type)
   1606    {
   1607        case GL_UNSIGNED_BYTE:
   1608            return LoadImageFunctionInfo(LoadCompressedToNative<4, 4, 1, 16>, true);
   1609        default:
   1610            UNREACHABLE();
   1611            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1612    }
   1613 }
   1614 
   1615 LoadImageFunctionInfo COMPRESSED_SRGB8_ALPHA8_ETC2_EAC_to_R8G8B8A8_UNORM_SRGB(GLenum type)
   1616 {
   1617    switch (type)
   1618    {
   1619        case GL_UNSIGNED_BYTE:
   1620            return LoadImageFunctionInfo(LoadETC2SRGBA8ToSRGBA8, true);
   1621        default:
   1622            UNREACHABLE();
   1623            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1624    }
   1625 }
   1626 
   1627 LoadImageFunctionInfo COMPRESSED_SRGB8_ETC2_to_ETC2_R8G8B8_SRGB_BLOCK(GLenum type)
   1628 {
   1629    switch (type)
   1630    {
   1631        case GL_UNSIGNED_BYTE:
   1632            return LoadImageFunctionInfo(LoadCompressedToNative<4, 4, 1, 8>, true);
   1633        default:
   1634            UNREACHABLE();
   1635            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1636    }
   1637 }
   1638 
   1639 LoadImageFunctionInfo COMPRESSED_SRGB8_ETC2_to_R8G8B8A8_UNORM_SRGB(GLenum type)
   1640 {
   1641    switch (type)
   1642    {
   1643        case GL_UNSIGNED_BYTE:
   1644            return LoadImageFunctionInfo(LoadETC2SRGB8ToRGBA8, true);
   1645        default:
   1646            UNREACHABLE();
   1647            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1648    }
   1649 }
   1650 
   1651 LoadImageFunctionInfo COMPRESSED_SRGB8_LOSSY_DECODE_ETC2_ANGLE_to_BC1_RGB_UNORM_SRGB_BLOCK(
   1652    GLenum type)
   1653 {
   1654    switch (type)
   1655    {
   1656        case GL_UNSIGNED_BYTE:
   1657            return LoadImageFunctionInfo(LoadETC2SRGB8ToBC1, true);
   1658        default:
   1659            UNREACHABLE();
   1660            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1661    }
   1662 }
   1663 
   1664 LoadImageFunctionInfo COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2_to_ETC2_R8G8B8A1_SRGB_BLOCK(
   1665    GLenum type)
   1666 {
   1667    switch (type)
   1668    {
   1669        case GL_UNSIGNED_BYTE:
   1670            return LoadImageFunctionInfo(LoadCompressedToNative<4, 4, 1, 8>, true);
   1671        default:
   1672            UNREACHABLE();
   1673            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1674    }
   1675 }
   1676 
   1677 LoadImageFunctionInfo COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2_to_R8G8B8A8_UNORM_SRGB(GLenum type)
   1678 {
   1679    switch (type)
   1680    {
   1681        case GL_UNSIGNED_BYTE:
   1682            return LoadImageFunctionInfo(LoadETC2SRGB8A1ToRGBA8, true);
   1683        default:
   1684            UNREACHABLE();
   1685            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1686    }
   1687 }
   1688 
   1689 LoadImageFunctionInfo
   1690 COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_LOSSY_DECODE_ETC2_ANGLE_to_BC1_RGBA_UNORM_SRGB_BLOCK(
   1691    GLenum type)
   1692 {
   1693    switch (type)
   1694    {
   1695        case GL_UNSIGNED_BYTE:
   1696            return LoadImageFunctionInfo(LoadETC2SRGB8A1ToBC1, true);
   1697        default:
   1698            UNREACHABLE();
   1699            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1700    }
   1701 }
   1702 
   1703 LoadImageFunctionInfo COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT_to_default(GLenum type)
   1704 {
   1705    switch (type)
   1706    {
   1707        case GL_UNSIGNED_BYTE:
   1708            return LoadImageFunctionInfo(LoadCompressedToNative<4, 4, 1, 16>, true);
   1709        default:
   1710            UNREACHABLE();
   1711            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1712    }
   1713 }
   1714 
   1715 LoadImageFunctionInfo COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT_to_default(GLenum type)
   1716 {
   1717    switch (type)
   1718    {
   1719        case GL_UNSIGNED_BYTE:
   1720            return LoadImageFunctionInfo(LoadCompressedToNative<4, 4, 1, 8>, true);
   1721        default:
   1722            UNREACHABLE();
   1723            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1724    }
   1725 }
   1726 
   1727 LoadImageFunctionInfo COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT_to_default(GLenum type)
   1728 {
   1729    switch (type)
   1730    {
   1731        case GL_UNSIGNED_BYTE:
   1732            return LoadImageFunctionInfo(LoadCompressedToNative<4, 4, 1, 16>, true);
   1733        default:
   1734            UNREACHABLE();
   1735            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1736    }
   1737 }
   1738 
   1739 LoadImageFunctionInfo COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT_to_default(GLenum type)
   1740 {
   1741    switch (type)
   1742    {
   1743        case GL_UNSIGNED_BYTE:
   1744            return LoadImageFunctionInfo(LoadCompressedToNative<4, 4, 1, 16>, true);
   1745        default:
   1746            UNREACHABLE();
   1747            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1748    }
   1749 }
   1750 
   1751 LoadImageFunctionInfo COMPRESSED_SRGB_S3TC_DXT1_EXT_to_default(GLenum type)
   1752 {
   1753    switch (type)
   1754    {
   1755        case GL_UNSIGNED_BYTE:
   1756            return LoadImageFunctionInfo(LoadCompressedToNative<4, 4, 1, 8>, true);
   1757        default:
   1758            UNREACHABLE();
   1759            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1760    }
   1761 }
   1762 
   1763 LoadImageFunctionInfo DEPTH24_STENCIL8_to_D24_UNORM_S8_UINT(GLenum type)
   1764 {
   1765    switch (type)
   1766    {
   1767        case GL_UNSIGNED_INT_24_8:
   1768            return LoadImageFunctionInfo(LoadR32ToR24G8, true);
   1769        default:
   1770            UNREACHABLE();
   1771            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1772    }
   1773 }
   1774 
   1775 LoadImageFunctionInfo DEPTH24_STENCIL8_to_D32_FLOAT_S8X24_UINT(GLenum type)
   1776 {
   1777    switch (type)
   1778    {
   1779        case GL_UNSIGNED_INT_24_8:
   1780            return LoadImageFunctionInfo(LoadD24S8ToD32FS8X24, true);
   1781        default:
   1782            UNREACHABLE();
   1783            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1784    }
   1785 }
   1786 
   1787 LoadImageFunctionInfo DEPTH32F_STENCIL8_to_D24_UNORM_S8_UINT(GLenum type)
   1788 {
   1789    switch (type)
   1790    {
   1791        case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
   1792            return LoadImageFunctionInfo(LoadD32FS8X24ToD24S8, true);
   1793        default:
   1794            UNREACHABLE();
   1795            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1796    }
   1797 }
   1798 
   1799 LoadImageFunctionInfo DEPTH32F_STENCIL8_to_D32_FLOAT_S8X24_UINT(GLenum type)
   1800 {
   1801    switch (type)
   1802    {
   1803        case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
   1804            return LoadImageFunctionInfo(LoadD32FS8X24ToD32FS8X24, true);
   1805        default:
   1806            UNREACHABLE();
   1807            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1808    }
   1809 }
   1810 
   1811 LoadImageFunctionInfo DEPTH_COMPONENT16_to_D16_UNORM(GLenum type)
   1812 {
   1813    switch (type)
   1814    {
   1815        case GL_UNSIGNED_INT:
   1816            return LoadImageFunctionInfo(LoadR32ToR16, true);
   1817        case GL_UNSIGNED_SHORT:
   1818            return LoadImageFunctionInfo(LoadToNative<GLushort, 1>, false);
   1819        default:
   1820            UNREACHABLE();
   1821            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1822    }
   1823 }
   1824 
   1825 LoadImageFunctionInfo DEPTH_COMPONENT16_to_D32_FLOAT(GLenum type)
   1826 {
   1827    switch (type)
   1828    {
   1829        case GL_UNSIGNED_INT:
   1830            return LoadImageFunctionInfo(LoadUNorm32To32F, true);
   1831        case GL_UNSIGNED_SHORT:
   1832            return LoadImageFunctionInfo(LoadUNorm16To32F, true);
   1833        default:
   1834            UNREACHABLE();
   1835            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1836    }
   1837 }
   1838 
   1839 LoadImageFunctionInfo DEPTH_COMPONENT24_to_D24_UNORM_S8_UINT(GLenum type)
   1840 {
   1841    switch (type)
   1842    {
   1843        case GL_UNSIGNED_INT:
   1844            return LoadImageFunctionInfo(LoadR32ToR24G8, true);
   1845        default:
   1846            UNREACHABLE();
   1847            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1848    }
   1849 }
   1850 
   1851 LoadImageFunctionInfo DEPTH_COMPONENT24_to_D24_UNORM_X8_UINT(GLenum type)
   1852 {
   1853    switch (type)
   1854    {
   1855        case GL_UNSIGNED_INT:
   1856            return LoadImageFunctionInfo(LoadR32ToR24G8, true);
   1857        default:
   1858            UNREACHABLE();
   1859            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1860    }
   1861 }
   1862 
   1863 LoadImageFunctionInfo DEPTH_COMPONENT24_to_D32_FLOAT(GLenum type)
   1864 {
   1865    switch (type)
   1866    {
   1867        case GL_UNSIGNED_INT:
   1868            return LoadImageFunctionInfo(LoadD24S8ToD32F, true);
   1869        default:
   1870            UNREACHABLE();
   1871            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1872    }
   1873 }
   1874 
   1875 LoadImageFunctionInfo DEPTH_COMPONENT24_to_D32_FLOAT_S8X24_UINT(GLenum type)
   1876 {
   1877    switch (type)
   1878    {
   1879        case GL_UNSIGNED_INT:
   1880            return LoadImageFunctionInfo(LoadD32ToD32FX32, true);
   1881        case GL_UNSIGNED_INT_24_8:
   1882            return LoadImageFunctionInfo(LoadD24S8ToD32FS8X24, true);
   1883        default:
   1884            UNREACHABLE();
   1885            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1886    }
   1887 }
   1888 
   1889 LoadImageFunctionInfo DEPTH_COMPONENT32F_to_D32_FLOAT(GLenum type)
   1890 {
   1891    switch (type)
   1892    {
   1893        case GL_FLOAT:
   1894            return LoadImageFunctionInfo(LoadD32FToD32F, true);
   1895        default:
   1896            UNREACHABLE();
   1897            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1898    }
   1899 }
   1900 
   1901 LoadImageFunctionInfo DEPTH_COMPONENT32_OES_to_D32_FLOAT(GLenum type)
   1902 {
   1903    switch (type)
   1904    {
   1905        case GL_UNSIGNED_INT:
   1906            return LoadImageFunctionInfo(LoadD32ToD32F, true);
   1907        default:
   1908            UNREACHABLE();
   1909            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1910    }
   1911 }
   1912 
   1913 LoadImageFunctionInfo DEPTH_COMPONENT32_OES_to_default(GLenum type)
   1914 {
   1915    switch (type)
   1916    {
   1917        case GL_UNSIGNED_INT:
   1918            return LoadImageFunctionInfo(LoadR32ToR24G8, true);
   1919        default:
   1920            UNREACHABLE();
   1921            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1922    }
   1923 }
   1924 
   1925 LoadImageFunctionInfo ETC1_RGB8_LOSSY_DECODE_ANGLE_to_BC1_RGB_UNORM_BLOCK(GLenum type)
   1926 {
   1927    switch (type)
   1928    {
   1929        case GL_UNSIGNED_BYTE:
   1930            return LoadImageFunctionInfo(LoadETC1RGB8ToBC1, true);
   1931        default:
   1932            UNREACHABLE();
   1933            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1934    }
   1935 }
   1936 
   1937 LoadImageFunctionInfo ETC1_RGB8_OES_to_ETC1_R8G8B8_UNORM_BLOCK(GLenum type)
   1938 {
   1939    switch (type)
   1940    {
   1941        case GL_UNSIGNED_BYTE:
   1942            return LoadImageFunctionInfo(LoadCompressedToNative<4, 4, 1, 8>, true);
   1943        default:
   1944            UNREACHABLE();
   1945            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1946    }
   1947 }
   1948 
   1949 LoadImageFunctionInfo ETC1_RGB8_OES_to_ETC2_R8G8B8_UNORM_BLOCK(GLenum type)
   1950 {
   1951    switch (type)
   1952    {
   1953        case GL_UNSIGNED_BYTE:
   1954            return LoadImageFunctionInfo(LoadCompressedToNative<4, 4, 1, 8>, true);
   1955        default:
   1956            UNREACHABLE();
   1957            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1958    }
   1959 }
   1960 
   1961 LoadImageFunctionInfo ETC1_RGB8_OES_to_R8G8B8A8_UNORM(GLenum type)
   1962 {
   1963    switch (type)
   1964    {
   1965        case GL_UNSIGNED_BYTE:
   1966            return LoadImageFunctionInfo(LoadETC1RGB8ToRGBA8, true);
   1967        default:
   1968            UNREACHABLE();
   1969            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1970    }
   1971 }
   1972 
   1973 LoadImageFunctionInfo G8_B8R8_2PLANE_420_UNORM_ANGLE_to_default(GLenum type)
   1974 {
   1975    switch (type)
   1976    {
   1977        case GL_UNSIGNED_BYTE:
   1978            return LoadImageFunctionInfo(LoadYuvToNative, true);
   1979        default:
   1980            UNREACHABLE();
   1981            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1982    }
   1983 }
   1984 
   1985 LoadImageFunctionInfo G8_B8_R8_3PLANE_420_UNORM_ANGLE_to_default(GLenum type)
   1986 {
   1987    switch (type)
   1988    {
   1989        case GL_UNSIGNED_BYTE:
   1990            return LoadImageFunctionInfo(UnimplementedLoadFunction, true);
   1991        default:
   1992            UNREACHABLE();
   1993            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   1994    }
   1995 }
   1996 
   1997 LoadImageFunctionInfo LUMINANCE_to_R16G16B16A16_FLOAT(GLenum type)
   1998 {
   1999    switch (type)
   2000    {
   2001        case GL_HALF_FLOAT:
   2002            return LoadImageFunctionInfo(LoadL16FToRGBA16F, true);
   2003        case GL_HALF_FLOAT_OES:
   2004            return LoadImageFunctionInfo(LoadL16FToRGBA16F, true);
   2005        case GL_UNSIGNED_BYTE:
   2006            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2007        default:
   2008            UNREACHABLE();
   2009            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2010    }
   2011 }
   2012 
   2013 LoadImageFunctionInfo LUMINANCE_to_R32G32B32A32_FLOAT(GLenum type)
   2014 {
   2015    switch (type)
   2016    {
   2017        case GL_FLOAT:
   2018            return LoadImageFunctionInfo(LoadL32FToRGBA32F, true);
   2019        case GL_UNSIGNED_BYTE:
   2020            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2021        default:
   2022            UNREACHABLE();
   2023            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2024    }
   2025 }
   2026 
   2027 LoadImageFunctionInfo LUMINANCE_to_default(GLenum type)
   2028 {
   2029    switch (type)
   2030    {
   2031        case GL_UNSIGNED_BYTE:
   2032            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2033        default:
   2034            UNREACHABLE();
   2035            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2036    }
   2037 }
   2038 
   2039 LoadImageFunctionInfo LUMINANCE16F_EXT_to_R16_FLOAT(GLenum type)
   2040 {
   2041    switch (type)
   2042    {
   2043        case GL_HALF_FLOAT:
   2044            return LoadImageFunctionInfo(LoadToNative<GLhalf, 1>, false);
   2045        case GL_HALF_FLOAT_OES:
   2046            return LoadImageFunctionInfo(LoadToNative<GLhalf, 1>, false);
   2047        default:
   2048            UNREACHABLE();
   2049            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2050    }
   2051 }
   2052 
   2053 LoadImageFunctionInfo LUMINANCE16F_EXT_to_default(GLenum type)
   2054 {
   2055    switch (type)
   2056    {
   2057        case GL_HALF_FLOAT:
   2058            return LoadImageFunctionInfo(LoadL16FToRGBA16F, true);
   2059        case GL_HALF_FLOAT_OES:
   2060            return LoadImageFunctionInfo(LoadL16FToRGBA16F, true);
   2061        default:
   2062            UNREACHABLE();
   2063            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2064    }
   2065 }
   2066 
   2067 LoadImageFunctionInfo LUMINANCE32F_EXT_to_R32_FLOAT(GLenum type)
   2068 {
   2069    switch (type)
   2070    {
   2071        case GL_FLOAT:
   2072            return LoadImageFunctionInfo(LoadToNative<GLfloat, 1>, false);
   2073        default:
   2074            UNREACHABLE();
   2075            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2076    }
   2077 }
   2078 
   2079 LoadImageFunctionInfo LUMINANCE32F_EXT_to_default(GLenum type)
   2080 {
   2081    switch (type)
   2082    {
   2083        case GL_FLOAT:
   2084            return LoadImageFunctionInfo(LoadL32FToRGBA32F, true);
   2085        default:
   2086            UNREACHABLE();
   2087            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2088    }
   2089 }
   2090 
   2091 LoadImageFunctionInfo LUMINANCE8_ALPHA8_EXT_to_R8G8B8A8_UNORM(GLenum type)
   2092 {
   2093    switch (type)
   2094    {
   2095        case GL_UNSIGNED_BYTE:
   2096            return LoadImageFunctionInfo(LoadLA8ToRGBA8, true);
   2097        default:
   2098            UNREACHABLE();
   2099            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2100    }
   2101 }
   2102 
   2103 LoadImageFunctionInfo LUMINANCE8_ALPHA8_EXT_to_R8G8_UNORM(GLenum type)
   2104 {
   2105    switch (type)
   2106    {
   2107        case GL_UNSIGNED_BYTE:
   2108            return LoadImageFunctionInfo(LoadToNative<GLubyte, 2>, false);
   2109        default:
   2110            UNREACHABLE();
   2111            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2112    }
   2113 }
   2114 
   2115 LoadImageFunctionInfo LUMINANCE8_EXT_to_R8G8B8A8_UNORM(GLenum type)
   2116 {
   2117    switch (type)
   2118    {
   2119        case GL_UNSIGNED_BYTE:
   2120            return LoadImageFunctionInfo(LoadL8ToRGBA8, true);
   2121        default:
   2122            UNREACHABLE();
   2123            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2124    }
   2125 }
   2126 
   2127 LoadImageFunctionInfo LUMINANCE8_EXT_to_R8_UNORM(GLenum type)
   2128 {
   2129    switch (type)
   2130    {
   2131        case GL_UNSIGNED_BYTE:
   2132            return LoadImageFunctionInfo(LoadToNative<GLubyte, 1>, false);
   2133        default:
   2134            UNREACHABLE();
   2135            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2136    }
   2137 }
   2138 
   2139 LoadImageFunctionInfo LUMINANCE_ALPHA_to_R16G16B16A16_FLOAT(GLenum type)
   2140 {
   2141    switch (type)
   2142    {
   2143        case GL_HALF_FLOAT:
   2144            return LoadImageFunctionInfo(LoadLA16FToRGBA16F, true);
   2145        case GL_HALF_FLOAT_OES:
   2146            return LoadImageFunctionInfo(LoadLA16FToRGBA16F, true);
   2147        case GL_UNSIGNED_BYTE:
   2148            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2149        default:
   2150            UNREACHABLE();
   2151            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2152    }
   2153 }
   2154 
   2155 LoadImageFunctionInfo LUMINANCE_ALPHA_to_R32G32B32A32_FLOAT(GLenum type)
   2156 {
   2157    switch (type)
   2158    {
   2159        case GL_FLOAT:
   2160            return LoadImageFunctionInfo(LoadLA32FToRGBA32F, true);
   2161        case GL_UNSIGNED_BYTE:
   2162            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2163        default:
   2164            UNREACHABLE();
   2165            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2166    }
   2167 }
   2168 
   2169 LoadImageFunctionInfo LUMINANCE_ALPHA_to_default(GLenum type)
   2170 {
   2171    switch (type)
   2172    {
   2173        case GL_UNSIGNED_BYTE:
   2174            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2175        default:
   2176            UNREACHABLE();
   2177            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2178    }
   2179 }
   2180 
   2181 LoadImageFunctionInfo LUMINANCE_ALPHA16F_EXT_to_R16G16_FLOAT(GLenum type)
   2182 {
   2183    switch (type)
   2184    {
   2185        case GL_HALF_FLOAT:
   2186            return LoadImageFunctionInfo(LoadToNative<GLhalf, 2>, false);
   2187        case GL_HALF_FLOAT_OES:
   2188            return LoadImageFunctionInfo(LoadToNative<GLhalf, 2>, false);
   2189        default:
   2190            UNREACHABLE();
   2191            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2192    }
   2193 }
   2194 
   2195 LoadImageFunctionInfo LUMINANCE_ALPHA16F_EXT_to_default(GLenum type)
   2196 {
   2197    switch (type)
   2198    {
   2199        case GL_HALF_FLOAT:
   2200            return LoadImageFunctionInfo(LoadLA16FToRGBA16F, true);
   2201        case GL_HALF_FLOAT_OES:
   2202            return LoadImageFunctionInfo(LoadLA16FToRGBA16F, true);
   2203        default:
   2204            UNREACHABLE();
   2205            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2206    }
   2207 }
   2208 
   2209 LoadImageFunctionInfo LUMINANCE_ALPHA32F_EXT_to_R32G32_FLOAT(GLenum type)
   2210 {
   2211    switch (type)
   2212    {
   2213        case GL_FLOAT:
   2214            return LoadImageFunctionInfo(LoadToNative<GLfloat, 2>, false);
   2215        default:
   2216            UNREACHABLE();
   2217            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2218    }
   2219 }
   2220 
   2221 LoadImageFunctionInfo LUMINANCE_ALPHA32F_EXT_to_default(GLenum type)
   2222 {
   2223    switch (type)
   2224    {
   2225        case GL_FLOAT:
   2226            return LoadImageFunctionInfo(LoadLA32FToRGBA32F, true);
   2227        default:
   2228            UNREACHABLE();
   2229            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2230    }
   2231 }
   2232 
   2233 LoadImageFunctionInfo PALETTE4_R5_G6_B5_OES_to_R8G8B8A8_UNORM(GLenum type)
   2234 {
   2235    switch (type)
   2236    {
   2237        case GL_UNSIGNED_BYTE:
   2238            return LoadImageFunctionInfo(LoadPalettedToRGBA8<4, 5, 6, 0>, true);
   2239        default:
   2240            UNREACHABLE();
   2241            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2242    }
   2243 }
   2244 
   2245 LoadImageFunctionInfo PALETTE4_RGB5_A1_OES_to_R8G8B8A8_UNORM(GLenum type)
   2246 {
   2247    switch (type)
   2248    {
   2249        case GL_UNSIGNED_BYTE:
   2250            return LoadImageFunctionInfo(LoadPalettedToRGBA8<4, 5, 5, 1>, true);
   2251        default:
   2252            UNREACHABLE();
   2253            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2254    }
   2255 }
   2256 
   2257 LoadImageFunctionInfo PALETTE4_RGB8_OES_to_R8G8B8A8_UNORM(GLenum type)
   2258 {
   2259    switch (type)
   2260    {
   2261        case GL_UNSIGNED_BYTE:
   2262            return LoadImageFunctionInfo(LoadPalettedToRGBA8<4, 8, 8, 0>, true);
   2263        default:
   2264            UNREACHABLE();
   2265            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2266    }
   2267 }
   2268 
   2269 LoadImageFunctionInfo PALETTE4_RGBA4_OES_to_R8G8B8A8_UNORM(GLenum type)
   2270 {
   2271    switch (type)
   2272    {
   2273        case GL_UNSIGNED_BYTE:
   2274            return LoadImageFunctionInfo(LoadPalettedToRGBA8<4, 4, 4, 4>, true);
   2275        default:
   2276            UNREACHABLE();
   2277            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2278    }
   2279 }
   2280 
   2281 LoadImageFunctionInfo PALETTE4_RGBA8_OES_to_R8G8B8A8_UNORM(GLenum type)
   2282 {
   2283    switch (type)
   2284    {
   2285        case GL_UNSIGNED_BYTE:
   2286            return LoadImageFunctionInfo(LoadPalettedToRGBA8<4, 8, 8, 8>, true);
   2287        default:
   2288            UNREACHABLE();
   2289            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2290    }
   2291 }
   2292 
   2293 LoadImageFunctionInfo PALETTE8_R5_G6_B5_OES_to_R8G8B8A8_UNORM(GLenum type)
   2294 {
   2295    switch (type)
   2296    {
   2297        case GL_UNSIGNED_BYTE:
   2298            return LoadImageFunctionInfo(LoadPalettedToRGBA8<8, 5, 6, 0>, true);
   2299        default:
   2300            UNREACHABLE();
   2301            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2302    }
   2303 }
   2304 
   2305 LoadImageFunctionInfo PALETTE8_RGB5_A1_OES_to_R8G8B8A8_UNORM(GLenum type)
   2306 {
   2307    switch (type)
   2308    {
   2309        case GL_UNSIGNED_BYTE:
   2310            return LoadImageFunctionInfo(LoadPalettedToRGBA8<8, 5, 5, 1>, true);
   2311        default:
   2312            UNREACHABLE();
   2313            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2314    }
   2315 }
   2316 
   2317 LoadImageFunctionInfo PALETTE8_RGB8_OES_to_R8G8B8A8_UNORM(GLenum type)
   2318 {
   2319    switch (type)
   2320    {
   2321        case GL_UNSIGNED_BYTE:
   2322            return LoadImageFunctionInfo(LoadPalettedToRGBA8<8, 8, 8, 0>, true);
   2323        default:
   2324            UNREACHABLE();
   2325            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2326    }
   2327 }
   2328 
   2329 LoadImageFunctionInfo PALETTE8_RGBA4_OES_to_R8G8B8A8_UNORM(GLenum type)
   2330 {
   2331    switch (type)
   2332    {
   2333        case GL_UNSIGNED_BYTE:
   2334            return LoadImageFunctionInfo(LoadPalettedToRGBA8<8, 4, 4, 4>, true);
   2335        default:
   2336            UNREACHABLE();
   2337            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2338    }
   2339 }
   2340 
   2341 LoadImageFunctionInfo PALETTE8_RGBA8_OES_to_R8G8B8A8_UNORM(GLenum type)
   2342 {
   2343    switch (type)
   2344    {
   2345        case GL_UNSIGNED_BYTE:
   2346            return LoadImageFunctionInfo(LoadPalettedToRGBA8<8, 8, 8, 8>, true);
   2347        default:
   2348            UNREACHABLE();
   2349            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2350    }
   2351 }
   2352 
   2353 LoadImageFunctionInfo R11F_G11F_B10F_to_R11G11B10_FLOAT(GLenum type)
   2354 {
   2355    switch (type)
   2356    {
   2357        case GL_FLOAT:
   2358            return LoadImageFunctionInfo(LoadRGB32FToRG11B10F, true);
   2359        case GL_HALF_FLOAT:
   2360            return LoadImageFunctionInfo(LoadRGB16FToRG11B10F, true);
   2361        case GL_HALF_FLOAT_OES:
   2362            return LoadImageFunctionInfo(LoadRGB16FToRG11B10F, true);
   2363        case GL_UNSIGNED_INT_10F_11F_11F_REV:
   2364            return LoadImageFunctionInfo(LoadToNative<GLuint, 1>, false);
   2365        default:
   2366            UNREACHABLE();
   2367            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2368    }
   2369 }
   2370 
   2371 LoadImageFunctionInfo R16F_to_R16_FLOAT(GLenum type)
   2372 {
   2373    switch (type)
   2374    {
   2375        case GL_FLOAT:
   2376            return LoadImageFunctionInfo(Load32FTo16F<1>, true);
   2377        case GL_HALF_FLOAT:
   2378            return LoadImageFunctionInfo(LoadToNative<GLhalf, 1>, false);
   2379        case GL_HALF_FLOAT_OES:
   2380            return LoadImageFunctionInfo(LoadToNative<GLhalf, 1>, false);
   2381        default:
   2382            UNREACHABLE();
   2383            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2384    }
   2385 }
   2386 
   2387 LoadImageFunctionInfo R16I_to_R16_SINT(GLenum type)
   2388 {
   2389    switch (type)
   2390    {
   2391        case GL_SHORT:
   2392            return LoadImageFunctionInfo(LoadToNative<GLshort, 1>, false);
   2393        default:
   2394            UNREACHABLE();
   2395            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2396    }
   2397 }
   2398 
   2399 LoadImageFunctionInfo R16UI_to_R16_UINT(GLenum type)
   2400 {
   2401    switch (type)
   2402    {
   2403        case GL_UNSIGNED_SHORT:
   2404            return LoadImageFunctionInfo(LoadToNative<GLushort, 1>, false);
   2405        default:
   2406            UNREACHABLE();
   2407            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2408    }
   2409 }
   2410 
   2411 LoadImageFunctionInfo R16_EXT_to_R16_UNORM(GLenum type)
   2412 {
   2413    switch (type)
   2414    {
   2415        case GL_UNSIGNED_SHORT:
   2416            return LoadImageFunctionInfo(LoadToNative<GLushort, 1>, false);
   2417        default:
   2418            UNREACHABLE();
   2419            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2420    }
   2421 }
   2422 
   2423 LoadImageFunctionInfo R16_SNORM_EXT_to_R16_SNORM(GLenum type)
   2424 {
   2425    switch (type)
   2426    {
   2427        case GL_SHORT:
   2428            return LoadImageFunctionInfo(LoadToNative<GLushort, 1>, false);
   2429        default:
   2430            UNREACHABLE();
   2431            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2432    }
   2433 }
   2434 
   2435 LoadImageFunctionInfo R16_SSCALED_ANGLEX_to_default(GLenum type)
   2436 {
   2437    switch (type)
   2438    {
   2439        case GL_UNSIGNED_BYTE:
   2440            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2441        default:
   2442            UNREACHABLE();
   2443            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2444    }
   2445 }
   2446 
   2447 LoadImageFunctionInfo R16_USCALED_ANGLEX_to_default(GLenum type)
   2448 {
   2449    switch (type)
   2450    {
   2451        case GL_UNSIGNED_BYTE:
   2452            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2453        default:
   2454            UNREACHABLE();
   2455            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2456    }
   2457 }
   2458 
   2459 LoadImageFunctionInfo R32F_to_R32_FLOAT(GLenum type)
   2460 {
   2461    switch (type)
   2462    {
   2463        case GL_FLOAT:
   2464            return LoadImageFunctionInfo(LoadToNative<GLfloat, 1>, false);
   2465        default:
   2466            UNREACHABLE();
   2467            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2468    }
   2469 }
   2470 
   2471 LoadImageFunctionInfo R32I_to_R32_SINT(GLenum type)
   2472 {
   2473    switch (type)
   2474    {
   2475        case GL_INT:
   2476            return LoadImageFunctionInfo(LoadToNative<GLint, 1>, false);
   2477        default:
   2478            UNREACHABLE();
   2479            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2480    }
   2481 }
   2482 
   2483 LoadImageFunctionInfo R32UI_to_R32_UINT(GLenum type)
   2484 {
   2485    switch (type)
   2486    {
   2487        case GL_UNSIGNED_INT:
   2488            return LoadImageFunctionInfo(LoadToNative<GLuint, 1>, false);
   2489        default:
   2490            UNREACHABLE();
   2491            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2492    }
   2493 }
   2494 
   2495 LoadImageFunctionInfo R8_to_R8_UNORM(GLenum type)
   2496 {
   2497    switch (type)
   2498    {
   2499        case GL_UNSIGNED_BYTE:
   2500            return LoadImageFunctionInfo(LoadToNative<GLubyte, 1>, false);
   2501        default:
   2502            UNREACHABLE();
   2503            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2504    }
   2505 }
   2506 
   2507 LoadImageFunctionInfo R8I_to_R8_SINT(GLenum type)
   2508 {
   2509    switch (type)
   2510    {
   2511        case GL_BYTE:
   2512            return LoadImageFunctionInfo(LoadToNative<GLbyte, 1>, false);
   2513        default:
   2514            UNREACHABLE();
   2515            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2516    }
   2517 }
   2518 
   2519 LoadImageFunctionInfo R8UI_to_R8_UINT(GLenum type)
   2520 {
   2521    switch (type)
   2522    {
   2523        case GL_UNSIGNED_BYTE:
   2524            return LoadImageFunctionInfo(LoadToNative<GLubyte, 1>, false);
   2525        default:
   2526            UNREACHABLE();
   2527            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2528    }
   2529 }
   2530 
   2531 LoadImageFunctionInfo R8_SNORM_to_R8_SNORM(GLenum type)
   2532 {
   2533    switch (type)
   2534    {
   2535        case GL_BYTE:
   2536            return LoadImageFunctionInfo(LoadToNative<GLbyte, 1>, false);
   2537        default:
   2538            UNREACHABLE();
   2539            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2540    }
   2541 }
   2542 
   2543 LoadImageFunctionInfo R8_SSCALED_ANGLEX_to_default(GLenum type)
   2544 {
   2545    switch (type)
   2546    {
   2547        case GL_UNSIGNED_BYTE:
   2548            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2549        default:
   2550            UNREACHABLE();
   2551            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2552    }
   2553 }
   2554 
   2555 LoadImageFunctionInfo R8_USCALED_ANGLEX_to_default(GLenum type)
   2556 {
   2557    switch (type)
   2558    {
   2559        case GL_UNSIGNED_BYTE:
   2560            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2561        default:
   2562            UNREACHABLE();
   2563            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2564    }
   2565 }
   2566 
   2567 LoadImageFunctionInfo RG16F_to_R16G16_FLOAT(GLenum type)
   2568 {
   2569    switch (type)
   2570    {
   2571        case GL_FLOAT:
   2572            return LoadImageFunctionInfo(Load32FTo16F<2>, true);
   2573        case GL_HALF_FLOAT:
   2574            return LoadImageFunctionInfo(LoadToNative<GLhalf, 2>, false);
   2575        case GL_HALF_FLOAT_OES:
   2576            return LoadImageFunctionInfo(LoadToNative<GLhalf, 2>, false);
   2577        default:
   2578            UNREACHABLE();
   2579            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2580    }
   2581 }
   2582 
   2583 LoadImageFunctionInfo RG16I_to_R16G16_SINT(GLenum type)
   2584 {
   2585    switch (type)
   2586    {
   2587        case GL_SHORT:
   2588            return LoadImageFunctionInfo(LoadToNative<GLshort, 2>, false);
   2589        default:
   2590            UNREACHABLE();
   2591            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2592    }
   2593 }
   2594 
   2595 LoadImageFunctionInfo RG16UI_to_R16G16_UINT(GLenum type)
   2596 {
   2597    switch (type)
   2598    {
   2599        case GL_UNSIGNED_SHORT:
   2600            return LoadImageFunctionInfo(LoadToNative<GLushort, 2>, false);
   2601        default:
   2602            UNREACHABLE();
   2603            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2604    }
   2605 }
   2606 
   2607 LoadImageFunctionInfo RG16_EXT_to_R16G16_UNORM(GLenum type)
   2608 {
   2609    switch (type)
   2610    {
   2611        case GL_UNSIGNED_SHORT:
   2612            return LoadImageFunctionInfo(LoadToNative<GLushort, 2>, false);
   2613        default:
   2614            UNREACHABLE();
   2615            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2616    }
   2617 }
   2618 
   2619 LoadImageFunctionInfo RG16_SNORM_EXT_to_R16G16_SNORM(GLenum type)
   2620 {
   2621    switch (type)
   2622    {
   2623        case GL_SHORT:
   2624            return LoadImageFunctionInfo(LoadToNative<GLushort, 2>, false);
   2625        default:
   2626            UNREACHABLE();
   2627            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2628    }
   2629 }
   2630 
   2631 LoadImageFunctionInfo RG16_SSCALED_ANGLEX_to_default(GLenum type)
   2632 {
   2633    switch (type)
   2634    {
   2635        case GL_UNSIGNED_BYTE:
   2636            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2637        default:
   2638            UNREACHABLE();
   2639            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2640    }
   2641 }
   2642 
   2643 LoadImageFunctionInfo RG16_USCALED_ANGLEX_to_default(GLenum type)
   2644 {
   2645    switch (type)
   2646    {
   2647        case GL_UNSIGNED_BYTE:
   2648            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2649        default:
   2650            UNREACHABLE();
   2651            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2652    }
   2653 }
   2654 
   2655 LoadImageFunctionInfo RG32F_to_R32G32_FLOAT(GLenum type)
   2656 {
   2657    switch (type)
   2658    {
   2659        case GL_FLOAT:
   2660            return LoadImageFunctionInfo(LoadToNative<GLfloat, 2>, false);
   2661        default:
   2662            UNREACHABLE();
   2663            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2664    }
   2665 }
   2666 
   2667 LoadImageFunctionInfo RG32I_to_R32G32_SINT(GLenum type)
   2668 {
   2669    switch (type)
   2670    {
   2671        case GL_INT:
   2672            return LoadImageFunctionInfo(LoadToNative<GLint, 2>, false);
   2673        default:
   2674            UNREACHABLE();
   2675            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2676    }
   2677 }
   2678 
   2679 LoadImageFunctionInfo RG32UI_to_R32G32_UINT(GLenum type)
   2680 {
   2681    switch (type)
   2682    {
   2683        case GL_UNSIGNED_INT:
   2684            return LoadImageFunctionInfo(LoadToNative<GLuint, 2>, false);
   2685        default:
   2686            UNREACHABLE();
   2687            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2688    }
   2689 }
   2690 
   2691 LoadImageFunctionInfo RG8_to_R8G8_UNORM(GLenum type)
   2692 {
   2693    switch (type)
   2694    {
   2695        case GL_UNSIGNED_BYTE:
   2696            return LoadImageFunctionInfo(LoadToNative<GLubyte, 2>, false);
   2697        default:
   2698            UNREACHABLE();
   2699            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2700    }
   2701 }
   2702 
   2703 LoadImageFunctionInfo RG8I_to_R8G8_SINT(GLenum type)
   2704 {
   2705    switch (type)
   2706    {
   2707        case GL_BYTE:
   2708            return LoadImageFunctionInfo(LoadToNative<GLbyte, 2>, false);
   2709        default:
   2710            UNREACHABLE();
   2711            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2712    }
   2713 }
   2714 
   2715 LoadImageFunctionInfo RG8UI_to_R8G8_UINT(GLenum type)
   2716 {
   2717    switch (type)
   2718    {
   2719        case GL_UNSIGNED_BYTE:
   2720            return LoadImageFunctionInfo(LoadToNative<GLubyte, 2>, false);
   2721        default:
   2722            UNREACHABLE();
   2723            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2724    }
   2725 }
   2726 
   2727 LoadImageFunctionInfo RG8_SNORM_to_R8G8_SNORM(GLenum type)
   2728 {
   2729    switch (type)
   2730    {
   2731        case GL_BYTE:
   2732            return LoadImageFunctionInfo(LoadToNative<GLbyte, 2>, false);
   2733        default:
   2734            UNREACHABLE();
   2735            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2736    }
   2737 }
   2738 
   2739 LoadImageFunctionInfo RG8_SSCALED_ANGLEX_to_default(GLenum type)
   2740 {
   2741    switch (type)
   2742    {
   2743        case GL_UNSIGNED_BYTE:
   2744            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2745        default:
   2746            UNREACHABLE();
   2747            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2748    }
   2749 }
   2750 
   2751 LoadImageFunctionInfo RG8_USCALED_ANGLEX_to_default(GLenum type)
   2752 {
   2753    switch (type)
   2754    {
   2755        case GL_UNSIGNED_BYTE:
   2756            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2757        default:
   2758            UNREACHABLE();
   2759            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2760    }
   2761 }
   2762 
   2763 LoadImageFunctionInfo RGB_to_default(GLenum type)
   2764 {
   2765    switch (type)
   2766    {
   2767        case GL_UNSIGNED_BYTE:
   2768            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2769        case GL_UNSIGNED_SHORT_5_6_5:
   2770            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2771        default:
   2772            UNREACHABLE();
   2773            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2774    }
   2775 }
   2776 
   2777 LoadImageFunctionInfo RGB10_A2_to_R10G10B10A2_UNORM(GLenum type)
   2778 {
   2779    switch (type)
   2780    {
   2781        case GL_UNSIGNED_INT_2_10_10_10_REV:
   2782            return LoadImageFunctionInfo(LoadToNative<GLuint, 1>, false);
   2783        default:
   2784            UNREACHABLE();
   2785            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2786    }
   2787 }
   2788 
   2789 LoadImageFunctionInfo RGB10_A2UI_to_R10G10B10A2_UINT(GLenum type)
   2790 {
   2791    switch (type)
   2792    {
   2793        case GL_UNSIGNED_INT_2_10_10_10_REV:
   2794            return LoadImageFunctionInfo(LoadToNative<GLuint, 1>, false);
   2795        default:
   2796            UNREACHABLE();
   2797            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2798    }
   2799 }
   2800 
   2801 LoadImageFunctionInfo RGB10_A2_SINT_ANGLEX_to_R10G10B10A2_SINT(GLenum type)
   2802 {
   2803    switch (type)
   2804    {
   2805        case GL_UNSIGNED_BYTE:
   2806            return LoadImageFunctionInfo(LoadRGB10A2ToRGBA8, true);
   2807        case GL_UNSIGNED_INT_2_10_10_10_REV:
   2808            return LoadImageFunctionInfo(LoadToNative<GLuint, 1>, false);
   2809        default:
   2810            UNREACHABLE();
   2811            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2812    }
   2813 }
   2814 
   2815 LoadImageFunctionInfo RGB10_A2_SNORM_ANGLEX_to_R10G10B10A2_SNORM(GLenum type)
   2816 {
   2817    switch (type)
   2818    {
   2819        case GL_UNSIGNED_BYTE:
   2820            return LoadImageFunctionInfo(LoadRGB10A2ToRGBA8, true);
   2821        case GL_UNSIGNED_INT_2_10_10_10_REV:
   2822            return LoadImageFunctionInfo(LoadToNative<GLuint, 1>, false);
   2823        default:
   2824            UNREACHABLE();
   2825            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2826    }
   2827 }
   2828 
   2829 LoadImageFunctionInfo RGB10_A2_SSCALED_ANGLEX_to_default(GLenum type)
   2830 {
   2831    switch (type)
   2832    {
   2833        case GL_UNSIGNED_BYTE:
   2834            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2835        default:
   2836            UNREACHABLE();
   2837            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2838    }
   2839 }
   2840 
   2841 LoadImageFunctionInfo RGB10_A2_USCALED_ANGLEX_to_default(GLenum type)
   2842 {
   2843    switch (type)
   2844    {
   2845        case GL_UNSIGNED_BYTE:
   2846            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2847        default:
   2848            UNREACHABLE();
   2849            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2850    }
   2851 }
   2852 
   2853 LoadImageFunctionInfo RGB10_UNORM_ANGLEX_to_R10G10B10A2_UNORM(GLenum type)
   2854 {
   2855    switch (type)
   2856    {
   2857        case GL_UNSIGNED_INT_2_10_10_10_REV:
   2858            return LoadImageFunctionInfo(LoadRGB10A2ToRGB10X2, true);
   2859        default:
   2860            UNREACHABLE();
   2861            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2862    }
   2863 }
   2864 
   2865 LoadImageFunctionInfo RGB10_UNORM_ANGLEX_to_R10G10B10X2_UNORM(GLenum type)
   2866 {
   2867    switch (type)
   2868    {
   2869        case GL_UNSIGNED_INT_2_10_10_10_REV:
   2870            return LoadImageFunctionInfo(LoadRGB10A2ToRGB10X2, true);
   2871        default:
   2872            UNREACHABLE();
   2873            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2874    }
   2875 }
   2876 
   2877 LoadImageFunctionInfo RGB16F_to_R16G16B16A16_FLOAT(GLenum type)
   2878 {
   2879    switch (type)
   2880    {
   2881        case GL_FLOAT:
   2882            return LoadImageFunctionInfo(LoadRGB32FToRGBA16F, true);
   2883        case GL_HALF_FLOAT:
   2884            return LoadImageFunctionInfo(LoadToNative3To4<GLhalf, gl::Float16One>, true);
   2885        case GL_HALF_FLOAT_OES:
   2886            return LoadImageFunctionInfo(LoadToNative3To4<GLhalf, gl::Float16One>, true);
   2887        default:
   2888            UNREACHABLE();
   2889            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2890    }
   2891 }
   2892 
   2893 LoadImageFunctionInfo RGB16F_to_R16G16B16_FLOAT(GLenum type)
   2894 {
   2895    switch (type)
   2896    {
   2897        case GL_FLOAT:
   2898            return LoadImageFunctionInfo(LoadRGB32FToRGB16F, true);
   2899        case GL_HALF_FLOAT:
   2900            return LoadImageFunctionInfo(LoadToNative<GLhalf, 3>, false);
   2901        case GL_HALF_FLOAT_OES:
   2902            return LoadImageFunctionInfo(LoadToNative<GLhalf, 3>, false);
   2903        default:
   2904            UNREACHABLE();
   2905            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2906    }
   2907 }
   2908 
   2909 LoadImageFunctionInfo RGB16I_to_R16G16B16A16_SINT(GLenum type)
   2910 {
   2911    switch (type)
   2912    {
   2913        case GL_SHORT:
   2914            return LoadImageFunctionInfo(LoadToNative3To4<GLshort, 0x0001>, true);
   2915        default:
   2916            UNREACHABLE();
   2917            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2918    }
   2919 }
   2920 
   2921 LoadImageFunctionInfo RGB16I_to_R16G16B16_SINT(GLenum type)
   2922 {
   2923    switch (type)
   2924    {
   2925        case GL_SHORT:
   2926            return LoadImageFunctionInfo(LoadToNative<GLshort, 3>, false);
   2927        default:
   2928            UNREACHABLE();
   2929            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2930    }
   2931 }
   2932 
   2933 LoadImageFunctionInfo RGB16UI_to_R16G16B16A16_UINT(GLenum type)
   2934 {
   2935    switch (type)
   2936    {
   2937        case GL_UNSIGNED_SHORT:
   2938            return LoadImageFunctionInfo(LoadToNative3To4<GLushort, 0x0001>, true);
   2939        default:
   2940            UNREACHABLE();
   2941            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2942    }
   2943 }
   2944 
   2945 LoadImageFunctionInfo RGB16UI_to_R16G16B16_UINT(GLenum type)
   2946 {
   2947    switch (type)
   2948    {
   2949        case GL_UNSIGNED_SHORT:
   2950            return LoadImageFunctionInfo(LoadToNative<GLushort, 3>, false);
   2951        default:
   2952            UNREACHABLE();
   2953            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2954    }
   2955 }
   2956 
   2957 LoadImageFunctionInfo RGB16_EXT_to_R16G16B16A16_UNORM(GLenum type)
   2958 {
   2959    switch (type)
   2960    {
   2961        case GL_UNSIGNED_SHORT:
   2962            return LoadImageFunctionInfo(LoadToNative3To4<GLushort, 0xFFFF>, true);
   2963        default:
   2964            UNREACHABLE();
   2965            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2966    }
   2967 }
   2968 
   2969 LoadImageFunctionInfo RGB16_EXT_to_R16G16B16_UNORM(GLenum type)
   2970 {
   2971    switch (type)
   2972    {
   2973        case GL_UNSIGNED_SHORT:
   2974            return LoadImageFunctionInfo(LoadToNative<GLushort, 3>, false);
   2975        default:
   2976            UNREACHABLE();
   2977            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2978    }
   2979 }
   2980 
   2981 LoadImageFunctionInfo RGB16_SNORM_EXT_to_R16G16B16A16_SNORM(GLenum type)
   2982 {
   2983    switch (type)
   2984    {
   2985        case GL_SHORT:
   2986            return LoadImageFunctionInfo(LoadToNative3To4<GLushort, 0x7FFF>, true);
   2987        default:
   2988            UNREACHABLE();
   2989            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   2990    }
   2991 }
   2992 
   2993 LoadImageFunctionInfo RGB16_SNORM_EXT_to_R16G16B16_SNORM(GLenum type)
   2994 {
   2995    switch (type)
   2996    {
   2997        case GL_SHORT:
   2998            return LoadImageFunctionInfo(LoadToNative<GLushort, 3>, false);
   2999        default:
   3000            UNREACHABLE();
   3001            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3002    }
   3003 }
   3004 
   3005 LoadImageFunctionInfo RGB16_SSCALED_ANGLEX_to_default(GLenum type)
   3006 {
   3007    switch (type)
   3008    {
   3009        case GL_UNSIGNED_BYTE:
   3010            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3011        default:
   3012            UNREACHABLE();
   3013            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3014    }
   3015 }
   3016 
   3017 LoadImageFunctionInfo RGB16_USCALED_ANGLEX_to_default(GLenum type)
   3018 {
   3019    switch (type)
   3020    {
   3021        case GL_UNSIGNED_BYTE:
   3022            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3023        default:
   3024            UNREACHABLE();
   3025            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3026    }
   3027 }
   3028 
   3029 LoadImageFunctionInfo RGB32F_to_R32G32B32A32_FLOAT(GLenum type)
   3030 {
   3031    switch (type)
   3032    {
   3033        case GL_FLOAT:
   3034            return LoadImageFunctionInfo(LoadToNative3To4<GLfloat, gl::Float32One>, true);
   3035        default:
   3036            UNREACHABLE();
   3037            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3038    }
   3039 }
   3040 
   3041 LoadImageFunctionInfo RGB32F_to_R32G32B32_FLOAT(GLenum type)
   3042 {
   3043    switch (type)
   3044    {
   3045        case GL_FLOAT:
   3046            return LoadImageFunctionInfo(LoadToNative<GLfloat, 3>, false);
   3047        default:
   3048            UNREACHABLE();
   3049            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3050    }
   3051 }
   3052 
   3053 LoadImageFunctionInfo RGB32I_to_R32G32B32A32_SINT(GLenum type)
   3054 {
   3055    switch (type)
   3056    {
   3057        case GL_INT:
   3058            return LoadImageFunctionInfo(LoadToNative3To4<GLint, 0x00000001>, true);
   3059        default:
   3060            UNREACHABLE();
   3061            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3062    }
   3063 }
   3064 
   3065 LoadImageFunctionInfo RGB32I_to_R32G32B32_SINT(GLenum type)
   3066 {
   3067    switch (type)
   3068    {
   3069        case GL_INT:
   3070            return LoadImageFunctionInfo(LoadToNative<GLint, 3>, false);
   3071        default:
   3072            UNREACHABLE();
   3073            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3074    }
   3075 }
   3076 
   3077 LoadImageFunctionInfo RGB32UI_to_R32G32B32A32_UINT(GLenum type)
   3078 {
   3079    switch (type)
   3080    {
   3081        case GL_UNSIGNED_INT:
   3082            return LoadImageFunctionInfo(LoadToNative3To4<GLuint, 0x00000001>, true);
   3083        default:
   3084            UNREACHABLE();
   3085            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3086    }
   3087 }
   3088 
   3089 LoadImageFunctionInfo RGB32UI_to_R32G32B32_UINT(GLenum type)
   3090 {
   3091    switch (type)
   3092    {
   3093        case GL_UNSIGNED_INT:
   3094            return LoadImageFunctionInfo(LoadToNative<GLuint, 3>, false);
   3095        default:
   3096            UNREACHABLE();
   3097            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3098    }
   3099 }
   3100 
   3101 LoadImageFunctionInfo RGB565_to_B5G6R5_UNORM(GLenum type)
   3102 {
   3103    switch (type)
   3104    {
   3105        case GL_UNSIGNED_BYTE:
   3106            return LoadImageFunctionInfo(LoadRGB8ToBGR565, true);
   3107        case GL_UNSIGNED_SHORT_5_6_5:
   3108            return LoadImageFunctionInfo(LoadToNative<GLushort, 1>, false);
   3109        default:
   3110            UNREACHABLE();
   3111            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3112    }
   3113 }
   3114 
   3115 LoadImageFunctionInfo RGB565_to_R5G6B5_UNORM(GLenum type)
   3116 {
   3117    switch (type)
   3118    {
   3119        case GL_UNSIGNED_BYTE:
   3120            return LoadImageFunctionInfo(LoadRGB8ToBGR565, true);
   3121        case GL_UNSIGNED_SHORT_5_6_5:
   3122            return LoadImageFunctionInfo(LoadToNative<GLushort, 1>, false);
   3123        default:
   3124            UNREACHABLE();
   3125            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3126    }
   3127 }
   3128 
   3129 LoadImageFunctionInfo RGB565_to_R8G8B8A8_UNORM(GLenum type)
   3130 {
   3131    switch (type)
   3132    {
   3133        case GL_UNSIGNED_BYTE:
   3134            return LoadImageFunctionInfo(LoadToNative3To4<GLubyte, 0xFF>, true);
   3135        case GL_UNSIGNED_SHORT_5_6_5:
   3136            return LoadImageFunctionInfo(LoadR5G6B5ToRGBA8, true);
   3137        default:
   3138            UNREACHABLE();
   3139            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3140    }
   3141 }
   3142 
   3143 LoadImageFunctionInfo RGB5_A1_to_A1R5G5B5_UNORM(GLenum type)
   3144 {
   3145    switch (type)
   3146    {
   3147        case GL_UNSIGNED_BYTE:
   3148            return LoadImageFunctionInfo(LoadRGBA8ToBGR5A1, true);
   3149        case GL_UNSIGNED_INT_2_10_10_10_REV:
   3150            return LoadImageFunctionInfo(LoadRGB10A2ToBGR5A1, true);
   3151        case GL_UNSIGNED_SHORT_5_5_5_1:
   3152            return LoadImageFunctionInfo(LoadRGB5A1ToA1RGB5, true);
   3153        default:
   3154            UNREACHABLE();
   3155            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3156    }
   3157 }
   3158 
   3159 LoadImageFunctionInfo RGB5_A1_to_B5G5R5A1_UNORM(GLenum type)
   3160 {
   3161    switch (type)
   3162    {
   3163        case GL_UNSIGNED_BYTE:
   3164            return LoadImageFunctionInfo(LoadRGBA8ToBGR5A1, true);
   3165        case GL_UNSIGNED_INT_2_10_10_10_REV:
   3166            return LoadImageFunctionInfo(LoadRGB10A2ToBGR5A1, true);
   3167        case GL_UNSIGNED_SHORT_5_5_5_1:
   3168            return LoadImageFunctionInfo(LoadRGB5A1ToA1RGB5, true);
   3169        default:
   3170            UNREACHABLE();
   3171            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3172    }
   3173 }
   3174 
   3175 LoadImageFunctionInfo RGB5_A1_to_R5G5B5A1_UNORM(GLenum type)
   3176 {
   3177    switch (type)
   3178    {
   3179        case GL_UNSIGNED_BYTE:
   3180            return LoadImageFunctionInfo(LoadRGBA8ToRGB5A1, true);
   3181        case GL_UNSIGNED_INT_2_10_10_10_REV:
   3182            return LoadImageFunctionInfo(LoadRGB10A2ToRGB5A1, true);
   3183        case GL_UNSIGNED_SHORT_5_5_5_1:
   3184            return LoadImageFunctionInfo(LoadToNative<GLushort, 1>, false);
   3185        default:
   3186            UNREACHABLE();
   3187            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3188    }
   3189 }
   3190 
   3191 LoadImageFunctionInfo RGB5_A1_to_R8G8B8A8_UNORM(GLenum type)
   3192 {
   3193    switch (type)
   3194    {
   3195        case GL_UNSIGNED_BYTE:
   3196            return LoadImageFunctionInfo(LoadToNative<GLubyte, 4>, false);
   3197        case GL_UNSIGNED_INT_2_10_10_10_REV:
   3198            return LoadImageFunctionInfo(LoadRGB10A2ToRGBA8, true);
   3199        case GL_UNSIGNED_SHORT_5_5_5_1:
   3200            return LoadImageFunctionInfo(LoadRGB5A1ToRGBA8, true);
   3201        default:
   3202            UNREACHABLE();
   3203            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3204    }
   3205 }
   3206 
   3207 LoadImageFunctionInfo RGB8_to_R8G8B8A8_UNORM(GLenum type)
   3208 {
   3209    switch (type)
   3210    {
   3211        case GL_UNSIGNED_BYTE:
   3212            return LoadImageFunctionInfo(LoadToNative3To4<GLubyte, 0xFF>, true);
   3213        default:
   3214            UNREACHABLE();
   3215            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3216    }
   3217 }
   3218 
   3219 LoadImageFunctionInfo RGB8_to_R8G8B8_UNORM(GLenum type)
   3220 {
   3221    switch (type)
   3222    {
   3223        case GL_UNSIGNED_BYTE:
   3224            return LoadImageFunctionInfo(LoadToNative<GLbyte, 3>, false);
   3225        default:
   3226            UNREACHABLE();
   3227            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3228    }
   3229 }
   3230 
   3231 LoadImageFunctionInfo RGB8I_to_R8G8B8A8_SINT(GLenum type)
   3232 {
   3233    switch (type)
   3234    {
   3235        case GL_BYTE:
   3236            return LoadImageFunctionInfo(LoadToNative3To4<GLbyte, 0x01>, true);
   3237        default:
   3238            UNREACHABLE();
   3239            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3240    }
   3241 }
   3242 
   3243 LoadImageFunctionInfo RGB8I_to_R8G8B8_SINT(GLenum type)
   3244 {
   3245    switch (type)
   3246    {
   3247        case GL_BYTE:
   3248            return LoadImageFunctionInfo(LoadToNative<GLbyte, 3>, false);
   3249        default:
   3250            UNREACHABLE();
   3251            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3252    }
   3253 }
   3254 
   3255 LoadImageFunctionInfo RGB8UI_to_R8G8B8A8_UINT(GLenum type)
   3256 {
   3257    switch (type)
   3258    {
   3259        case GL_UNSIGNED_BYTE:
   3260            return LoadImageFunctionInfo(LoadToNative3To4<GLubyte, 0x01>, true);
   3261        default:
   3262            UNREACHABLE();
   3263            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3264    }
   3265 }
   3266 
   3267 LoadImageFunctionInfo RGB8UI_to_R8G8B8_UINT(GLenum type)
   3268 {
   3269    switch (type)
   3270    {
   3271        case GL_UNSIGNED_BYTE:
   3272            return LoadImageFunctionInfo(LoadToNative<GLubyte, 3>, false);
   3273        default:
   3274            UNREACHABLE();
   3275            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3276    }
   3277 }
   3278 
   3279 LoadImageFunctionInfo RGB8_SNORM_to_R8G8B8A8_SNORM(GLenum type)
   3280 {
   3281    switch (type)
   3282    {
   3283        case GL_BYTE:
   3284            return LoadImageFunctionInfo(LoadToNative3To4<GLbyte, 0x7F>, true);
   3285        default:
   3286            UNREACHABLE();
   3287            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3288    }
   3289 }
   3290 
   3291 LoadImageFunctionInfo RGB8_SNORM_to_R8G8B8_SNORM(GLenum type)
   3292 {
   3293    switch (type)
   3294    {
   3295        case GL_BYTE:
   3296            return LoadImageFunctionInfo(LoadToNative<GLbyte, 3>, false);
   3297        default:
   3298            UNREACHABLE();
   3299            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3300    }
   3301 }
   3302 
   3303 LoadImageFunctionInfo RGB8_SSCALED_ANGLEX_to_default(GLenum type)
   3304 {
   3305    switch (type)
   3306    {
   3307        case GL_UNSIGNED_BYTE:
   3308            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3309        default:
   3310            UNREACHABLE();
   3311            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3312    }
   3313 }
   3314 
   3315 LoadImageFunctionInfo RGB8_USCALED_ANGLEX_to_default(GLenum type)
   3316 {
   3317    switch (type)
   3318    {
   3319        case GL_UNSIGNED_BYTE:
   3320            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3321        default:
   3322            UNREACHABLE();
   3323            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3324    }
   3325 }
   3326 
   3327 LoadImageFunctionInfo RGB9_E5_to_R9G9B9E5_SHAREDEXP(GLenum type)
   3328 {
   3329    switch (type)
   3330    {
   3331        case GL_FLOAT:
   3332            return LoadImageFunctionInfo(LoadRGB32FToRGB9E5, true);
   3333        case GL_HALF_FLOAT:
   3334            return LoadImageFunctionInfo(LoadRGB16FToRGB9E5, true);
   3335        case GL_HALF_FLOAT_OES:
   3336            return LoadImageFunctionInfo(LoadRGB16FToRGB9E5, true);
   3337        case GL_UNSIGNED_INT_5_9_9_9_REV:
   3338            return LoadImageFunctionInfo(LoadToNative<GLuint, 1>, false);
   3339        default:
   3340            UNREACHABLE();
   3341            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3342    }
   3343 }
   3344 
   3345 LoadImageFunctionInfo RGBA_to_default(GLenum type)
   3346 {
   3347    switch (type)
   3348    {
   3349        case GL_UNSIGNED_BYTE:
   3350            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3351        case GL_UNSIGNED_SHORT_4_4_4_4:
   3352            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3353        case GL_UNSIGNED_SHORT_5_5_5_1:
   3354            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3355        default:
   3356            UNREACHABLE();
   3357            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3358    }
   3359 }
   3360 
   3361 LoadImageFunctionInfo RGBA16F_to_R16G16B16A16_FLOAT(GLenum type)
   3362 {
   3363    switch (type)
   3364    {
   3365        case GL_FLOAT:
   3366            return LoadImageFunctionInfo(Load32FTo16F<4>, true);
   3367        case GL_HALF_FLOAT:
   3368            return LoadImageFunctionInfo(LoadToNative<GLhalf, 4>, false);
   3369        case GL_HALF_FLOAT_OES:
   3370            return LoadImageFunctionInfo(LoadToNative<GLhalf, 4>, false);
   3371        default:
   3372            UNREACHABLE();
   3373            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3374    }
   3375 }
   3376 
   3377 LoadImageFunctionInfo RGBA16I_to_R16G16B16A16_SINT(GLenum type)
   3378 {
   3379    switch (type)
   3380    {
   3381        case GL_SHORT:
   3382            return LoadImageFunctionInfo(LoadToNative<GLshort, 4>, false);
   3383        default:
   3384            UNREACHABLE();
   3385            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3386    }
   3387 }
   3388 
   3389 LoadImageFunctionInfo RGBA16UI_to_R16G16B16A16_UINT(GLenum type)
   3390 {
   3391    switch (type)
   3392    {
   3393        case GL_UNSIGNED_SHORT:
   3394            return LoadImageFunctionInfo(LoadToNative<GLushort, 4>, false);
   3395        default:
   3396            UNREACHABLE();
   3397            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3398    }
   3399 }
   3400 
   3401 LoadImageFunctionInfo RGBA16_EXT_to_R16G16B16A16_UNORM(GLenum type)
   3402 {
   3403    switch (type)
   3404    {
   3405        case GL_UNSIGNED_SHORT:
   3406            return LoadImageFunctionInfo(LoadToNative<GLushort, 4>, false);
   3407        default:
   3408            UNREACHABLE();
   3409            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3410    }
   3411 }
   3412 
   3413 LoadImageFunctionInfo RGBA16_SNORM_EXT_to_R16G16B16A16_SNORM(GLenum type)
   3414 {
   3415    switch (type)
   3416    {
   3417        case GL_SHORT:
   3418            return LoadImageFunctionInfo(LoadToNative<GLushort, 4>, false);
   3419        default:
   3420            UNREACHABLE();
   3421            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3422    }
   3423 }
   3424 
   3425 LoadImageFunctionInfo RGBA16_SSCALED_ANGLEX_to_default(GLenum type)
   3426 {
   3427    switch (type)
   3428    {
   3429        case GL_UNSIGNED_BYTE:
   3430            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3431        default:
   3432            UNREACHABLE();
   3433            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3434    }
   3435 }
   3436 
   3437 LoadImageFunctionInfo RGBA16_USCALED_ANGLEX_to_default(GLenum type)
   3438 {
   3439    switch (type)
   3440    {
   3441        case GL_UNSIGNED_BYTE:
   3442            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3443        default:
   3444            UNREACHABLE();
   3445            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3446    }
   3447 }
   3448 
   3449 LoadImageFunctionInfo RGBA32F_to_R32G32B32A32_FLOAT(GLenum type)
   3450 {
   3451    switch (type)
   3452    {
   3453        case GL_FLOAT:
   3454            return LoadImageFunctionInfo(LoadToNative<GLfloat, 4>, false);
   3455        default:
   3456            UNREACHABLE();
   3457            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3458    }
   3459 }
   3460 
   3461 LoadImageFunctionInfo RGBA32I_to_R32G32B32A32_SINT(GLenum type)
   3462 {
   3463    switch (type)
   3464    {
   3465        case GL_INT:
   3466            return LoadImageFunctionInfo(LoadToNative<GLint, 4>, false);
   3467        default:
   3468            UNREACHABLE();
   3469            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3470    }
   3471 }
   3472 
   3473 LoadImageFunctionInfo RGBA32UI_to_R32G32B32A32_UINT(GLenum type)
   3474 {
   3475    switch (type)
   3476    {
   3477        case GL_UNSIGNED_INT:
   3478            return LoadImageFunctionInfo(LoadToNative<GLuint, 4>, false);
   3479        default:
   3480            UNREACHABLE();
   3481            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3482    }
   3483 }
   3484 
   3485 LoadImageFunctionInfo RGBA4_to_B4G4R4A4_UNORM(GLenum type)
   3486 {
   3487    switch (type)
   3488    {
   3489        case GL_UNSIGNED_BYTE:
   3490            return LoadImageFunctionInfo(LoadRGBA8ToBGRA4, true);
   3491        case GL_UNSIGNED_SHORT_4_4_4_4:
   3492            return LoadImageFunctionInfo(LoadRGBA4ToARGB4, true);
   3493        default:
   3494            UNREACHABLE();
   3495            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3496    }
   3497 }
   3498 
   3499 LoadImageFunctionInfo RGBA4_to_R4G4B4A4_UNORM(GLenum type)
   3500 {
   3501    switch (type)
   3502    {
   3503        case GL_UNSIGNED_BYTE:
   3504            return LoadImageFunctionInfo(LoadRGBA8ToRGBA4, true);
   3505        case GL_UNSIGNED_SHORT_4_4_4_4:
   3506            return LoadImageFunctionInfo(LoadToNative<GLushort, 1>, false);
   3507        default:
   3508            UNREACHABLE();
   3509            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3510    }
   3511 }
   3512 
   3513 LoadImageFunctionInfo RGBA4_to_R8G8B8A8_UNORM(GLenum type)
   3514 {
   3515    switch (type)
   3516    {
   3517        case GL_UNSIGNED_BYTE:
   3518            return LoadImageFunctionInfo(LoadToNative<GLubyte, 4>, false);
   3519        case GL_UNSIGNED_SHORT_4_4_4_4:
   3520            return LoadImageFunctionInfo(LoadRGBA4ToRGBA8, true);
   3521        default:
   3522            UNREACHABLE();
   3523            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3524    }
   3525 }
   3526 
   3527 LoadImageFunctionInfo RGBA8_to_R8G8B8A8_UNORM(GLenum type)
   3528 {
   3529    switch (type)
   3530    {
   3531        case GL_UNSIGNED_BYTE:
   3532            return LoadImageFunctionInfo(LoadToNative<GLubyte, 4>, false);
   3533        default:
   3534            UNREACHABLE();
   3535            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3536    }
   3537 }
   3538 
   3539 LoadImageFunctionInfo RGBA8I_to_R8G8B8A8_SINT(GLenum type)
   3540 {
   3541    switch (type)
   3542    {
   3543        case GL_BYTE:
   3544            return LoadImageFunctionInfo(LoadToNative<GLbyte, 4>, false);
   3545        default:
   3546            UNREACHABLE();
   3547            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3548    }
   3549 }
   3550 
   3551 LoadImageFunctionInfo RGBA8UI_to_R8G8B8A8_UINT(GLenum type)
   3552 {
   3553    switch (type)
   3554    {
   3555        case GL_UNSIGNED_BYTE:
   3556            return LoadImageFunctionInfo(LoadToNative<GLubyte, 4>, false);
   3557        default:
   3558            UNREACHABLE();
   3559            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3560    }
   3561 }
   3562 
   3563 LoadImageFunctionInfo RGBA8_SNORM_to_R8G8B8A8_SNORM(GLenum type)
   3564 {
   3565    switch (type)
   3566    {
   3567        case GL_BYTE:
   3568            return LoadImageFunctionInfo(LoadToNative<GLbyte, 4>, false);
   3569        default:
   3570            UNREACHABLE();
   3571            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3572    }
   3573 }
   3574 
   3575 LoadImageFunctionInfo RGBA8_SSCALED_ANGLEX_to_default(GLenum type)
   3576 {
   3577    switch (type)
   3578    {
   3579        case GL_UNSIGNED_BYTE:
   3580            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3581        default:
   3582            UNREACHABLE();
   3583            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3584    }
   3585 }
   3586 
   3587 LoadImageFunctionInfo RGBA8_USCALED_ANGLEX_to_default(GLenum type)
   3588 {
   3589    switch (type)
   3590    {
   3591        case GL_UNSIGNED_BYTE:
   3592            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3593        default:
   3594            UNREACHABLE();
   3595            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3596    }
   3597 }
   3598 
   3599 LoadImageFunctionInfo RGBX8_ANGLE_to_R8G8B8A8_UNORM(GLenum type)
   3600 {
   3601    switch (type)
   3602    {
   3603        case GL_UNSIGNED_BYTE:
   3604            return LoadImageFunctionInfo(LoadToNative3To4<GLubyte, 0xFF>, true);
   3605        default:
   3606            UNREACHABLE();
   3607            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3608    }
   3609 }
   3610 
   3611 LoadImageFunctionInfo RGBX8_ANGLE_to_R8G8B8X8_UNORM(GLenum type)
   3612 {
   3613    switch (type)
   3614    {
   3615        case GL_UNSIGNED_BYTE:
   3616            return LoadImageFunctionInfo(LoadToNative3To4<GLubyte, 0xFF>, true);
   3617        default:
   3618            UNREACHABLE();
   3619            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3620    }
   3621 }
   3622 
   3623 LoadImageFunctionInfo SR8_EXT_to_R8_UNORM_SRGB(GLenum type)
   3624 {
   3625    switch (type)
   3626    {
   3627        case GL_UNSIGNED_BYTE:
   3628            return LoadImageFunctionInfo(LoadToNative<GLbyte, 1>, false);
   3629        default:
   3630            UNREACHABLE();
   3631            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3632    }
   3633 }
   3634 
   3635 LoadImageFunctionInfo SRG8_EXT_to_R8G8_UNORM_SRGB(GLenum type)
   3636 {
   3637    switch (type)
   3638    {
   3639        case GL_UNSIGNED_BYTE:
   3640            return LoadImageFunctionInfo(LoadToNative<GLbyte, 2>, false);
   3641        default:
   3642            UNREACHABLE();
   3643            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3644    }
   3645 }
   3646 
   3647 LoadImageFunctionInfo SRGB8_to_R8G8B8A8_UNORM_SRGB(GLenum type)
   3648 {
   3649    switch (type)
   3650    {
   3651        case GL_UNSIGNED_BYTE:
   3652            return LoadImageFunctionInfo(LoadToNative3To4<GLubyte, 0xFF>, true);
   3653        default:
   3654            UNREACHABLE();
   3655            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3656    }
   3657 }
   3658 
   3659 LoadImageFunctionInfo SRGB8_to_R8G8B8_UNORM_SRGB(GLenum type)
   3660 {
   3661    switch (type)
   3662    {
   3663        case GL_UNSIGNED_BYTE:
   3664            return LoadImageFunctionInfo(LoadToNative<GLbyte, 3>, false);
   3665        default:
   3666            UNREACHABLE();
   3667            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3668    }
   3669 }
   3670 
   3671 LoadImageFunctionInfo SRGB8_ALPHA8_to_R8G8B8A8_UNORM_SRGB(GLenum type)
   3672 {
   3673    switch (type)
   3674    {
   3675        case GL_UNSIGNED_BYTE:
   3676            return LoadImageFunctionInfo(LoadToNative<GLubyte, 4>, false);
   3677        default:
   3678            UNREACHABLE();
   3679            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3680    }
   3681 }
   3682 
   3683 LoadImageFunctionInfo STENCIL_INDEX8_to_S8_UINT(GLenum type)
   3684 {
   3685    switch (type)
   3686    {
   3687        case GL_UNSIGNED_BYTE:
   3688            return LoadImageFunctionInfo(LoadToNative<GLubyte, 1>, false);
   3689        default:
   3690            UNREACHABLE();
   3691            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3692    }
   3693 }
   3694 
   3695 LoadImageFunctionInfo STENCIL_INDEX8_to_default(GLenum type)
   3696 {
   3697    switch (type)
   3698    {
   3699        case GL_UNSIGNED_BYTE:
   3700            return LoadImageFunctionInfo(UnimplementedLoadFunction, true);
   3701        default:
   3702            UNREACHABLE();
   3703            return LoadImageFunctionInfo(UnreachableLoadFunction, true);
   3704    }
   3705 }
   3706 
   3707 }  // namespace
   3708 
   3709 LoadFunctionMap GetLoadFunctionsMap(GLenum internalFormat, FormatID angleFormat)
   3710 {
   3711    // clang-format off
   3712    switch (internalFormat)
   3713    {
   3714        case GL_A1RGB5_ANGLEX:
   3715        {
   3716            switch (angleFormat)
   3717            {
   3718                case FormatID::A1R5G5B5_UNORM:
   3719                    return A1RGB5_ANGLEX_to_A1R5G5B5_UNORM;
   3720                default:
   3721                    break;
   3722            }
   3723            break;
   3724        }
   3725        case GL_ALPHA:
   3726        {
   3727            switch (angleFormat)
   3728            {
   3729                case FormatID::R16G16B16A16_FLOAT:
   3730                    return ALPHA_to_R16G16B16A16_FLOAT;
   3731                case FormatID::R32G32B32A32_FLOAT:
   3732                    return ALPHA_to_R32G32B32A32_FLOAT;
   3733                default:
   3734                    return ALPHA_to_default;
   3735            }
   3736        }
   3737        case GL_ALPHA16F_EXT:
   3738        {
   3739            switch (angleFormat)
   3740            {
   3741                case FormatID::R16_FLOAT:
   3742                    return ALPHA16F_EXT_to_R16_FLOAT;
   3743                default:
   3744                    return ALPHA16F_EXT_to_default;
   3745            }
   3746        }
   3747        case GL_ALPHA32F_EXT:
   3748        {
   3749            switch (angleFormat)
   3750            {
   3751                case FormatID::R32_FLOAT:
   3752                    return ALPHA32F_EXT_to_R32_FLOAT;
   3753                default:
   3754                    return ALPHA32F_EXT_to_default;
   3755            }
   3756        }
   3757        case GL_ALPHA8_EXT:
   3758        {
   3759            switch (angleFormat)
   3760            {
   3761                case FormatID::A8_UNORM:
   3762                    return ALPHA8_EXT_to_A8_UNORM;
   3763                case FormatID::R8G8B8A8_UNORM:
   3764                    return ALPHA8_EXT_to_R8G8B8A8_UNORM;
   3765                case FormatID::R8_UNORM:
   3766                    return ALPHA8_EXT_to_R8_UNORM;
   3767                default:
   3768                    break;
   3769            }
   3770            break;
   3771        }
   3772        case GL_BGR10_A2_ANGLEX:
   3773        {
   3774            switch (angleFormat)
   3775            {
   3776                case FormatID::B10G10R10A2_UNORM:
   3777                    return BGR10_A2_ANGLEX_to_B10G10R10A2_UNORM;
   3778                default:
   3779                    break;
   3780            }
   3781            break;
   3782        }
   3783        case GL_BGR565_ANGLEX:
   3784        {
   3785            switch (angleFormat)
   3786            {
   3787                case FormatID::B5G6R5_UNORM:
   3788                    return BGR565_ANGLEX_to_B5G6R5_UNORM;
   3789                default:
   3790                    break;
   3791            }
   3792            break;
   3793        }
   3794        case GL_BGR5_A1_ANGLEX:
   3795            return BGR5_A1_ANGLEX_to_default;
   3796        case GL_BGRA4_ANGLEX:
   3797            return BGRA4_ANGLEX_to_default;
   3798        case GL_BGRA8_EXT:
   3799            return BGRA8_EXT_to_default;
   3800        case GL_BGRA8_SRGB_ANGLEX:
   3801        {
   3802            switch (angleFormat)
   3803            {
   3804                case FormatID::B8G8R8A8_UNORM_SRGB:
   3805                    return BGRA8_SRGB_ANGLEX_to_B8G8R8A8_UNORM_SRGB;
   3806                default:
   3807                    break;
   3808            }
   3809            break;
   3810        }
   3811        case GL_BGRA_EXT:
   3812            return BGRA_EXT_to_default;
   3813        case GL_BGRX8_ANGLEX:
   3814        {
   3815            switch (angleFormat)
   3816            {
   3817                case FormatID::B8G8R8A8_UNORM:
   3818                    return BGRX8_ANGLEX_to_B8G8R8A8_UNORM;
   3819                case FormatID::B8G8R8X8_UNORM:
   3820                    return BGRX8_ANGLEX_to_B8G8R8X8_UNORM;
   3821                default:
   3822                    break;
   3823            }
   3824            break;
   3825        }
   3826        case GL_COMPRESSED_R11_EAC:
   3827        {
   3828            switch (angleFormat)
   3829            {
   3830                case FormatID::EAC_R11_UNORM_BLOCK:
   3831                    return COMPRESSED_R11_EAC_to_EAC_R11_UNORM_BLOCK;
   3832                case FormatID::R16_FLOAT:
   3833                    return COMPRESSED_R11_EAC_to_R16_FLOAT;
   3834                case FormatID::R16_UNORM:
   3835                    return COMPRESSED_R11_EAC_to_R16_UNORM;
   3836                default:
   3837                    break;
   3838            }
   3839            break;
   3840        }
   3841        case GL_COMPRESSED_RED_GREEN_RGTC2_EXT:
   3842            return COMPRESSED_RED_GREEN_RGTC2_EXT_to_default;
   3843        case GL_COMPRESSED_RED_RGTC1_EXT:
   3844            return COMPRESSED_RED_RGTC1_EXT_to_default;
   3845        case GL_COMPRESSED_RG11_EAC:
   3846        {
   3847            switch (angleFormat)
   3848            {
   3849                case FormatID::EAC_R11G11_UNORM_BLOCK:
   3850                    return COMPRESSED_RG11_EAC_to_EAC_R11G11_UNORM_BLOCK;
   3851                case FormatID::R16G16_FLOAT:
   3852                    return COMPRESSED_RG11_EAC_to_R16G16_FLOAT;
   3853                case FormatID::R16G16_UNORM:
   3854                    return COMPRESSED_RG11_EAC_to_R16G16_UNORM;
   3855                default:
   3856                    break;
   3857            }
   3858            break;
   3859        }
   3860        case GL_COMPRESSED_RGB8_ETC2:
   3861        {
   3862            switch (angleFormat)
   3863            {
   3864                case FormatID::ETC2_R8G8B8_UNORM_BLOCK:
   3865                    return COMPRESSED_RGB8_ETC2_to_ETC2_R8G8B8_UNORM_BLOCK;
   3866                case FormatID::R8G8B8A8_UNORM:
   3867                    return COMPRESSED_RGB8_ETC2_to_R8G8B8A8_UNORM;
   3868                default:
   3869                    break;
   3870            }
   3871            break;
   3872        }
   3873        case GL_COMPRESSED_RGB8_LOSSY_DECODE_ETC2_ANGLE:
   3874        {
   3875            switch (angleFormat)
   3876            {
   3877                case FormatID::BC1_RGB_UNORM_BLOCK:
   3878                    return COMPRESSED_RGB8_LOSSY_DECODE_ETC2_ANGLE_to_BC1_RGB_UNORM_BLOCK;
   3879                default:
   3880                    break;
   3881            }
   3882            break;
   3883        }
   3884        case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
   3885        {
   3886            switch (angleFormat)
   3887            {
   3888                case FormatID::ETC2_R8G8B8A1_UNORM_BLOCK:
   3889                    return COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2_to_ETC2_R8G8B8A1_UNORM_BLOCK;
   3890                case FormatID::R8G8B8A8_UNORM:
   3891                    return COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2_to_R8G8B8A8_UNORM;
   3892                default:
   3893                    break;
   3894            }
   3895            break;
   3896        }
   3897        case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_LOSSY_DECODE_ETC2_ANGLE:
   3898        {
   3899            switch (angleFormat)
   3900            {
   3901                case FormatID::BC1_RGBA_UNORM_BLOCK:
   3902                    return COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_LOSSY_DECODE_ETC2_ANGLE_to_BC1_RGBA_UNORM_BLOCK;
   3903                default:
   3904                    break;
   3905            }
   3906            break;
   3907        }
   3908        case GL_COMPRESSED_RGBA8_ETC2_EAC:
   3909        {
   3910            switch (angleFormat)
   3911            {
   3912                case FormatID::ETC2_R8G8B8A8_UNORM_BLOCK:
   3913                    return COMPRESSED_RGBA8_ETC2_EAC_to_ETC2_R8G8B8A8_UNORM_BLOCK;
   3914                case FormatID::R8G8B8A8_UNORM:
   3915                    return COMPRESSED_RGBA8_ETC2_EAC_to_R8G8B8A8_UNORM;
   3916                default:
   3917                    break;
   3918            }
   3919            break;
   3920        }
   3921        case GL_COMPRESSED_RGBA_ASTC_10x10_KHR:
   3922        {
   3923            switch (angleFormat)
   3924            {
   3925                case FormatID::R8G8B8A8_UNORM:
   3926                    return COMPRESSED_RGBA_ASTC_10x10_KHR_to_R8G8B8A8_UNORM;
   3927                default:
   3928                    return COMPRESSED_RGBA_ASTC_10x10_KHR_to_default;
   3929            }
   3930        }
   3931        case GL_COMPRESSED_RGBA_ASTC_10x5_KHR:
   3932        {
   3933            switch (angleFormat)
   3934            {
   3935                case FormatID::R8G8B8A8_UNORM:
   3936                    return COMPRESSED_RGBA_ASTC_10x5_KHR_to_R8G8B8A8_UNORM;
   3937                default:
   3938                    return COMPRESSED_RGBA_ASTC_10x5_KHR_to_default;
   3939            }
   3940        }
   3941        case GL_COMPRESSED_RGBA_ASTC_10x6_KHR:
   3942        {
   3943            switch (angleFormat)
   3944            {
   3945                case FormatID::R8G8B8A8_UNORM:
   3946                    return COMPRESSED_RGBA_ASTC_10x6_KHR_to_R8G8B8A8_UNORM;
   3947                default:
   3948                    return COMPRESSED_RGBA_ASTC_10x6_KHR_to_default;
   3949            }
   3950        }
   3951        case GL_COMPRESSED_RGBA_ASTC_10x8_KHR:
   3952        {
   3953            switch (angleFormat)
   3954            {
   3955                case FormatID::R8G8B8A8_UNORM:
   3956                    return COMPRESSED_RGBA_ASTC_10x8_KHR_to_R8G8B8A8_UNORM;
   3957                default:
   3958                    return COMPRESSED_RGBA_ASTC_10x8_KHR_to_default;
   3959            }
   3960        }
   3961        case GL_COMPRESSED_RGBA_ASTC_12x10_KHR:
   3962        {
   3963            switch (angleFormat)
   3964            {
   3965                case FormatID::R8G8B8A8_UNORM:
   3966                    return COMPRESSED_RGBA_ASTC_12x10_KHR_to_R8G8B8A8_UNORM;
   3967                default:
   3968                    return COMPRESSED_RGBA_ASTC_12x10_KHR_to_default;
   3969            }
   3970        }
   3971        case GL_COMPRESSED_RGBA_ASTC_12x12_KHR:
   3972        {
   3973            switch (angleFormat)
   3974            {
   3975                case FormatID::R8G8B8A8_UNORM:
   3976                    return COMPRESSED_RGBA_ASTC_12x12_KHR_to_R8G8B8A8_UNORM;
   3977                default:
   3978                    return COMPRESSED_RGBA_ASTC_12x12_KHR_to_default;
   3979            }
   3980        }
   3981        case GL_COMPRESSED_RGBA_ASTC_3x3x3_OES:
   3982            return COMPRESSED_RGBA_ASTC_3x3x3_OES_to_default;
   3983        case GL_COMPRESSED_RGBA_ASTC_4x3x3_OES:
   3984            return COMPRESSED_RGBA_ASTC_4x3x3_OES_to_default;
   3985        case GL_COMPRESSED_RGBA_ASTC_4x4_KHR:
   3986        {
   3987            switch (angleFormat)
   3988            {
   3989                case FormatID::R8G8B8A8_UNORM:
   3990                    return COMPRESSED_RGBA_ASTC_4x4_KHR_to_R8G8B8A8_UNORM;
   3991                default:
   3992                    return COMPRESSED_RGBA_ASTC_4x4_KHR_to_default;
   3993            }
   3994        }
   3995        case GL_COMPRESSED_RGBA_ASTC_4x4x3_OES:
   3996            return COMPRESSED_RGBA_ASTC_4x4x3_OES_to_default;
   3997        case GL_COMPRESSED_RGBA_ASTC_4x4x4_OES:
   3998            return COMPRESSED_RGBA_ASTC_4x4x4_OES_to_default;
   3999        case GL_COMPRESSED_RGBA_ASTC_5x4_KHR:
   4000        {
   4001            switch (angleFormat)
   4002            {
   4003                case FormatID::R8G8B8A8_UNORM:
   4004                    return COMPRESSED_RGBA_ASTC_5x4_KHR_to_R8G8B8A8_UNORM;
   4005                default:
   4006                    return COMPRESSED_RGBA_ASTC_5x4_KHR_to_default;
   4007            }
   4008        }
   4009        case GL_COMPRESSED_RGBA_ASTC_5x4x4_OES:
   4010            return COMPRESSED_RGBA_ASTC_5x4x4_OES_to_default;
   4011        case GL_COMPRESSED_RGBA_ASTC_5x5_KHR:
   4012        {
   4013            switch (angleFormat)
   4014            {
   4015                case FormatID::R8G8B8A8_UNORM:
   4016                    return COMPRESSED_RGBA_ASTC_5x5_KHR_to_R8G8B8A8_UNORM;
   4017                default:
   4018                    return COMPRESSED_RGBA_ASTC_5x5_KHR_to_default;
   4019            }
   4020        }
   4021        case GL_COMPRESSED_RGBA_ASTC_5x5x4_OES:
   4022            return COMPRESSED_RGBA_ASTC_5x5x4_OES_to_default;
   4023        case GL_COMPRESSED_RGBA_ASTC_5x5x5_OES:
   4024            return COMPRESSED_RGBA_ASTC_5x5x5_OES_to_default;
   4025        case GL_COMPRESSED_RGBA_ASTC_6x5_KHR:
   4026        {
   4027            switch (angleFormat)
   4028            {
   4029                case FormatID::R8G8B8A8_UNORM:
   4030                    return COMPRESSED_RGBA_ASTC_6x5_KHR_to_R8G8B8A8_UNORM;
   4031                default:
   4032                    return COMPRESSED_RGBA_ASTC_6x5_KHR_to_default;
   4033            }
   4034        }
   4035        case GL_COMPRESSED_RGBA_ASTC_6x5x5_OES:
   4036            return COMPRESSED_RGBA_ASTC_6x5x5_OES_to_default;
   4037        case GL_COMPRESSED_RGBA_ASTC_6x6_KHR:
   4038        {
   4039            switch (angleFormat)
   4040            {
   4041                case FormatID::R8G8B8A8_UNORM:
   4042                    return COMPRESSED_RGBA_ASTC_6x6_KHR_to_R8G8B8A8_UNORM;
   4043                default:
   4044                    return COMPRESSED_RGBA_ASTC_6x6_KHR_to_default;
   4045            }
   4046        }
   4047        case GL_COMPRESSED_RGBA_ASTC_6x6x5_OES:
   4048            return COMPRESSED_RGBA_ASTC_6x6x5_OES_to_default;
   4049        case GL_COMPRESSED_RGBA_ASTC_6x6x6_OES:
   4050            return COMPRESSED_RGBA_ASTC_6x6x6_OES_to_default;
   4051        case GL_COMPRESSED_RGBA_ASTC_8x5_KHR:
   4052        {
   4053            switch (angleFormat)
   4054            {
   4055                case FormatID::R8G8B8A8_UNORM:
   4056                    return COMPRESSED_RGBA_ASTC_8x5_KHR_to_R8G8B8A8_UNORM;
   4057                default:
   4058                    return COMPRESSED_RGBA_ASTC_8x5_KHR_to_default;
   4059            }
   4060        }
   4061        case GL_COMPRESSED_RGBA_ASTC_8x6_KHR:
   4062        {
   4063            switch (angleFormat)
   4064            {
   4065                case FormatID::R8G8B8A8_UNORM:
   4066                    return COMPRESSED_RGBA_ASTC_8x6_KHR_to_R8G8B8A8_UNORM;
   4067                default:
   4068                    return COMPRESSED_RGBA_ASTC_8x6_KHR_to_default;
   4069            }
   4070        }
   4071        case GL_COMPRESSED_RGBA_ASTC_8x8_KHR:
   4072        {
   4073            switch (angleFormat)
   4074            {
   4075                case FormatID::R8G8B8A8_UNORM:
   4076                    return COMPRESSED_RGBA_ASTC_8x8_KHR_to_R8G8B8A8_UNORM;
   4077                default:
   4078                    return COMPRESSED_RGBA_ASTC_8x8_KHR_to_default;
   4079            }
   4080        }
   4081        case GL_COMPRESSED_RGBA_BPTC_UNORM_EXT:
   4082            return COMPRESSED_RGBA_BPTC_UNORM_EXT_to_default;
   4083        case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
   4084            return COMPRESSED_RGBA_S3TC_DXT1_EXT_to_default;
   4085        case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE:
   4086            return COMPRESSED_RGBA_S3TC_DXT3_ANGLE_to_default;
   4087        case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE:
   4088            return COMPRESSED_RGBA_S3TC_DXT5_ANGLE_to_default;
   4089        case GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT:
   4090            return COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT_to_default;
   4091        case GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT:
   4092            return COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT_to_default;
   4093        case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
   4094            return COMPRESSED_RGB_S3TC_DXT1_EXT_to_default;
   4095        case GL_COMPRESSED_SIGNED_R11_EAC:
   4096        {
   4097            switch (angleFormat)
   4098            {
   4099                case FormatID::EAC_R11_SNORM_BLOCK:
   4100                    return COMPRESSED_SIGNED_R11_EAC_to_EAC_R11_SNORM_BLOCK;
   4101                case FormatID::R16_FLOAT:
   4102                    return COMPRESSED_SIGNED_R11_EAC_to_R16_FLOAT;
   4103                case FormatID::R16_SNORM:
   4104                    return COMPRESSED_SIGNED_R11_EAC_to_R16_SNORM;
   4105                default:
   4106                    break;
   4107            }
   4108            break;
   4109        }
   4110        case GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT:
   4111            return COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT_to_default;
   4112        case GL_COMPRESSED_SIGNED_RED_RGTC1_EXT:
   4113            return COMPRESSED_SIGNED_RED_RGTC1_EXT_to_default;
   4114        case GL_COMPRESSED_SIGNED_RG11_EAC:
   4115        {
   4116            switch (angleFormat)
   4117            {
   4118                case FormatID::EAC_R11G11_SNORM_BLOCK:
   4119                    return COMPRESSED_SIGNED_RG11_EAC_to_EAC_R11G11_SNORM_BLOCK;
   4120                case FormatID::R16G16_FLOAT:
   4121                    return COMPRESSED_SIGNED_RG11_EAC_to_R16G16_FLOAT;
   4122                case FormatID::R16G16_SNORM:
   4123                    return COMPRESSED_SIGNED_RG11_EAC_to_R16G16_SNORM;
   4124                default:
   4125                    break;
   4126            }
   4127            break;
   4128        }
   4129        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:
   4130        {
   4131            switch (angleFormat)
   4132            {
   4133                case FormatID::R8G8B8A8_UNORM_SRGB:
   4134                    return COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR_to_R8G8B8A8_UNORM_SRGB;
   4135                default:
   4136                    return COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR_to_default;
   4137            }
   4138        }
   4139        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:
   4140        {
   4141            switch (angleFormat)
   4142            {
   4143                case FormatID::R8G8B8A8_UNORM_SRGB:
   4144                    return COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR_to_R8G8B8A8_UNORM_SRGB;
   4145                default:
   4146                    return COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR_to_default;
   4147            }
   4148        }
   4149        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:
   4150        {
   4151            switch (angleFormat)
   4152            {
   4153                case FormatID::R8G8B8A8_UNORM_SRGB:
   4154                    return COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR_to_R8G8B8A8_UNORM_SRGB;
   4155                default:
   4156                    return COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR_to_default;
   4157            }
   4158        }
   4159        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:
   4160        {
   4161            switch (angleFormat)
   4162            {
   4163                case FormatID::R8G8B8A8_UNORM_SRGB:
   4164                    return COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR_to_R8G8B8A8_UNORM_SRGB;
   4165                default:
   4166                    return COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR_to_default;
   4167            }
   4168        }
   4169        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:
   4170        {
   4171            switch (angleFormat)
   4172            {
   4173                case FormatID::R8G8B8A8_UNORM_SRGB:
   4174                    return COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR_to_R8G8B8A8_UNORM_SRGB;
   4175                default:
   4176                    return COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR_to_default;
   4177            }
   4178        }
   4179        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:
   4180        {
   4181            switch (angleFormat)
   4182            {
   4183                case FormatID::R8G8B8A8_UNORM_SRGB:
   4184                    return COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR_to_R8G8B8A8_UNORM_SRGB;
   4185                default:
   4186                    return COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR_to_default;
   4187            }
   4188        }
   4189        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES:
   4190            return COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES_to_default;
   4191        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES:
   4192            return COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES_to_default;
   4193        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:
   4194        {
   4195            switch (angleFormat)
   4196            {
   4197                case FormatID::R8G8B8A8_UNORM_SRGB:
   4198                    return COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR_to_R8G8B8A8_UNORM_SRGB;
   4199                default:
   4200                    return COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR_to_default;
   4201            }
   4202        }
   4203        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES:
   4204            return COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES_to_default;
   4205        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES:
   4206            return COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES_to_default;
   4207        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:
   4208        {
   4209            switch (angleFormat)
   4210            {
   4211                case FormatID::R8G8B8A8_UNORM_SRGB:
   4212                    return COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR_to_R8G8B8A8_UNORM_SRGB;
   4213                default:
   4214                    return COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR_to_default;
   4215            }
   4216        }
   4217        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES:
   4218            return COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES_to_default;
   4219        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:
   4220        {
   4221            switch (angleFormat)
   4222            {
   4223                case FormatID::R8G8B8A8_UNORM_SRGB:
   4224                    return COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR_to_R8G8B8A8_UNORM_SRGB;
   4225                default:
   4226                    return COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR_to_default;
   4227            }
   4228        }
   4229        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES:
   4230            return COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES_to_default;
   4231        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES:
   4232            return COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES_to_default;
   4233        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:
   4234        {
   4235            switch (angleFormat)
   4236            {
   4237                case FormatID::R8G8B8A8_UNORM_SRGB:
   4238                    return COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR_to_R8G8B8A8_UNORM_SRGB;
   4239                default:
   4240                    return COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR_to_default;
   4241            }
   4242        }
   4243        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES:
   4244            return COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES_to_default;
   4245        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:
   4246        {
   4247            switch (angleFormat)
   4248            {
   4249                case FormatID::R8G8B8A8_UNORM_SRGB:
   4250                    return COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR_to_R8G8B8A8_UNORM_SRGB;
   4251                default:
   4252                    return COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR_to_default;
   4253            }
   4254        }
   4255        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES:
   4256            return COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES_to_default;
   4257        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES:
   4258            return COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES_to_default;
   4259        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR:
   4260        {
   4261            switch (angleFormat)
   4262            {
   4263                case FormatID::R8G8B8A8_UNORM_SRGB:
   4264                    return COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR_to_R8G8B8A8_UNORM_SRGB;
   4265                default:
   4266                    return COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR_to_default;
   4267            }
   4268        }
   4269        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:
   4270        {
   4271            switch (angleFormat)
   4272            {
   4273                case FormatID::R8G8B8A8_UNORM_SRGB:
   4274                    return COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR_to_R8G8B8A8_UNORM_SRGB;
   4275                default:
   4276                    return COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR_to_default;
   4277            }
   4278        }
   4279        case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:
   4280        {
   4281            switch (angleFormat)
   4282            {
   4283                case FormatID::R8G8B8A8_UNORM_SRGB:
   4284                    return COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR_to_R8G8B8A8_UNORM_SRGB;
   4285                default:
   4286                    return COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR_to_default;
   4287            }
   4288        }
   4289        case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
   4290        {
   4291            switch (angleFormat)
   4292            {
   4293                case FormatID::ETC2_R8G8B8A8_SRGB_BLOCK:
   4294                    return COMPRESSED_SRGB8_ALPHA8_ETC2_EAC_to_ETC2_R8G8B8A8_SRGB_BLOCK;
   4295                case FormatID::R8G8B8A8_UNORM_SRGB:
   4296                    return COMPRESSED_SRGB8_ALPHA8_ETC2_EAC_to_R8G8B8A8_UNORM_SRGB;
   4297                default:
   4298                    break;
   4299            }
   4300            break;
   4301        }
   4302        case GL_COMPRESSED_SRGB8_ETC2:
   4303        {
   4304            switch (angleFormat)
   4305            {
   4306                case FormatID::ETC2_R8G8B8_SRGB_BLOCK:
   4307                    return COMPRESSED_SRGB8_ETC2_to_ETC2_R8G8B8_SRGB_BLOCK;
   4308                case FormatID::R8G8B8A8_UNORM_SRGB:
   4309                    return COMPRESSED_SRGB8_ETC2_to_R8G8B8A8_UNORM_SRGB;
   4310                default:
   4311                    break;
   4312            }
   4313            break;
   4314        }
   4315        case GL_COMPRESSED_SRGB8_LOSSY_DECODE_ETC2_ANGLE:
   4316        {
   4317            switch (angleFormat)
   4318            {
   4319                case FormatID::BC1_RGB_UNORM_SRGB_BLOCK:
   4320                    return COMPRESSED_SRGB8_LOSSY_DECODE_ETC2_ANGLE_to_BC1_RGB_UNORM_SRGB_BLOCK;
   4321                default:
   4322                    break;
   4323            }
   4324            break;
   4325        }
   4326        case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
   4327        {
   4328            switch (angleFormat)
   4329            {
   4330                case FormatID::ETC2_R8G8B8A1_SRGB_BLOCK:
   4331                    return COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2_to_ETC2_R8G8B8A1_SRGB_BLOCK;
   4332                case FormatID::R8G8B8A8_UNORM_SRGB:
   4333                    return COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2_to_R8G8B8A8_UNORM_SRGB;
   4334                default:
   4335                    break;
   4336            }
   4337            break;
   4338        }
   4339        case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_LOSSY_DECODE_ETC2_ANGLE:
   4340        {
   4341            switch (angleFormat)
   4342            {
   4343                case FormatID::BC1_RGBA_UNORM_SRGB_BLOCK:
   4344                    return COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_LOSSY_DECODE_ETC2_ANGLE_to_BC1_RGBA_UNORM_SRGB_BLOCK;
   4345                default:
   4346                    break;
   4347            }
   4348            break;
   4349        }
   4350        case GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT:
   4351            return COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT_to_default;
   4352        case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
   4353            return COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT_to_default;
   4354        case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
   4355            return COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT_to_default;
   4356        case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
   4357            return COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT_to_default;
   4358        case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
   4359            return COMPRESSED_SRGB_S3TC_DXT1_EXT_to_default;
   4360        case GL_DEPTH24_STENCIL8:
   4361        {
   4362            switch (angleFormat)
   4363            {
   4364                case FormatID::D24_UNORM_S8_UINT:
   4365                    return DEPTH24_STENCIL8_to_D24_UNORM_S8_UINT;
   4366                case FormatID::D32_FLOAT_S8X24_UINT:
   4367                    return DEPTH24_STENCIL8_to_D32_FLOAT_S8X24_UINT;
   4368                default:
   4369                    break;
   4370            }
   4371            break;
   4372        }
   4373        case GL_DEPTH32F_STENCIL8:
   4374        {
   4375            switch (angleFormat)
   4376            {
   4377                case FormatID::D24_UNORM_S8_UINT:
   4378                    return DEPTH32F_STENCIL8_to_D24_UNORM_S8_UINT;
   4379                case FormatID::D32_FLOAT_S8X24_UINT:
   4380                    return DEPTH32F_STENCIL8_to_D32_FLOAT_S8X24_UINT;
   4381                default:
   4382                    break;
   4383            }
   4384            break;
   4385        }
   4386        case GL_DEPTH_COMPONENT16:
   4387        {
   4388            switch (angleFormat)
   4389            {
   4390                case FormatID::D16_UNORM:
   4391                    return DEPTH_COMPONENT16_to_D16_UNORM;
   4392                case FormatID::D32_FLOAT:
   4393                    return DEPTH_COMPONENT16_to_D32_FLOAT;
   4394                default:
   4395                    break;
   4396            }
   4397            break;
   4398        }
   4399        case GL_DEPTH_COMPONENT24:
   4400        {
   4401            switch (angleFormat)
   4402            {
   4403                case FormatID::D24_UNORM_S8_UINT:
   4404                    return DEPTH_COMPONENT24_to_D24_UNORM_S8_UINT;
   4405                case FormatID::D24_UNORM_X8_UINT:
   4406                    return DEPTH_COMPONENT24_to_D24_UNORM_X8_UINT;
   4407                case FormatID::D32_FLOAT:
   4408                    return DEPTH_COMPONENT24_to_D32_FLOAT;
   4409                case FormatID::D32_FLOAT_S8X24_UINT:
   4410                    return DEPTH_COMPONENT24_to_D32_FLOAT_S8X24_UINT;
   4411                default:
   4412                    break;
   4413            }
   4414            break;
   4415        }
   4416        case GL_DEPTH_COMPONENT32F:
   4417        {
   4418            switch (angleFormat)
   4419            {
   4420                case FormatID::D32_FLOAT:
   4421                    return DEPTH_COMPONENT32F_to_D32_FLOAT;
   4422                default:
   4423                    break;
   4424            }
   4425            break;
   4426        }
   4427        case GL_DEPTH_COMPONENT32_OES:
   4428        {
   4429            switch (angleFormat)
   4430            {
   4431                case FormatID::D32_FLOAT:
   4432                    return DEPTH_COMPONENT32_OES_to_D32_FLOAT;
   4433                default:
   4434                    return DEPTH_COMPONENT32_OES_to_default;
   4435            }
   4436        }
   4437        case GL_ETC1_RGB8_LOSSY_DECODE_ANGLE:
   4438        {
   4439            switch (angleFormat)
   4440            {
   4441                case FormatID::BC1_RGB_UNORM_BLOCK:
   4442                    return ETC1_RGB8_LOSSY_DECODE_ANGLE_to_BC1_RGB_UNORM_BLOCK;
   4443                default:
   4444                    break;
   4445            }
   4446            break;
   4447        }
   4448        case GL_ETC1_RGB8_OES:
   4449        {
   4450            switch (angleFormat)
   4451            {
   4452                case FormatID::ETC1_R8G8B8_UNORM_BLOCK:
   4453                    return ETC1_RGB8_OES_to_ETC1_R8G8B8_UNORM_BLOCK;
   4454                case FormatID::ETC2_R8G8B8_UNORM_BLOCK:
   4455                    return ETC1_RGB8_OES_to_ETC2_R8G8B8_UNORM_BLOCK;
   4456                case FormatID::R8G8B8A8_UNORM:
   4457                    return ETC1_RGB8_OES_to_R8G8B8A8_UNORM;
   4458                default:
   4459                    break;
   4460            }
   4461            break;
   4462        }
   4463        case GL_G8_B8R8_2PLANE_420_UNORM_ANGLE:
   4464            return G8_B8R8_2PLANE_420_UNORM_ANGLE_to_default;
   4465        case GL_G8_B8_R8_3PLANE_420_UNORM_ANGLE:
   4466            return G8_B8_R8_3PLANE_420_UNORM_ANGLE_to_default;
   4467        case GL_LUMINANCE:
   4468        {
   4469            switch (angleFormat)
   4470            {
   4471                case FormatID::R16G16B16A16_FLOAT:
   4472                    return LUMINANCE_to_R16G16B16A16_FLOAT;
   4473                case FormatID::R32G32B32A32_FLOAT:
   4474                    return LUMINANCE_to_R32G32B32A32_FLOAT;
   4475                default:
   4476                    return LUMINANCE_to_default;
   4477            }
   4478        }
   4479        case GL_LUMINANCE16F_EXT:
   4480        {
   4481            switch (angleFormat)
   4482            {
   4483                case FormatID::R16_FLOAT:
   4484                    return LUMINANCE16F_EXT_to_R16_FLOAT;
   4485                default:
   4486                    return LUMINANCE16F_EXT_to_default;
   4487            }
   4488        }
   4489        case GL_LUMINANCE32F_EXT:
   4490        {
   4491            switch (angleFormat)
   4492            {
   4493                case FormatID::R32_FLOAT:
   4494                    return LUMINANCE32F_EXT_to_R32_FLOAT;
   4495                default:
   4496                    return LUMINANCE32F_EXT_to_default;
   4497            }
   4498        }
   4499        case GL_LUMINANCE8_ALPHA8_EXT:
   4500        {
   4501            switch (angleFormat)
   4502            {
   4503                case FormatID::R8G8B8A8_UNORM:
   4504                    return LUMINANCE8_ALPHA8_EXT_to_R8G8B8A8_UNORM;
   4505                case FormatID::R8G8_UNORM:
   4506                    return LUMINANCE8_ALPHA8_EXT_to_R8G8_UNORM;
   4507                default:
   4508                    break;
   4509            }
   4510            break;
   4511        }
   4512        case GL_LUMINANCE8_EXT:
   4513        {
   4514            switch (angleFormat)
   4515            {
   4516                case FormatID::R8G8B8A8_UNORM:
   4517                    return LUMINANCE8_EXT_to_R8G8B8A8_UNORM;
   4518                case FormatID::R8_UNORM:
   4519                    return LUMINANCE8_EXT_to_R8_UNORM;
   4520                default:
   4521                    break;
   4522            }
   4523            break;
   4524        }
   4525        case GL_LUMINANCE_ALPHA:
   4526        {
   4527            switch (angleFormat)
   4528            {
   4529                case FormatID::R16G16B16A16_FLOAT:
   4530                    return LUMINANCE_ALPHA_to_R16G16B16A16_FLOAT;
   4531                case FormatID::R32G32B32A32_FLOAT:
   4532                    return LUMINANCE_ALPHA_to_R32G32B32A32_FLOAT;
   4533                default:
   4534                    return LUMINANCE_ALPHA_to_default;
   4535            }
   4536        }
   4537        case GL_LUMINANCE_ALPHA16F_EXT:
   4538        {
   4539            switch (angleFormat)
   4540            {
   4541                case FormatID::R16G16_FLOAT:
   4542                    return LUMINANCE_ALPHA16F_EXT_to_R16G16_FLOAT;
   4543                default:
   4544                    return LUMINANCE_ALPHA16F_EXT_to_default;
   4545            }
   4546        }
   4547        case GL_LUMINANCE_ALPHA32F_EXT:
   4548        {
   4549            switch (angleFormat)
   4550            {
   4551                case FormatID::R32G32_FLOAT:
   4552                    return LUMINANCE_ALPHA32F_EXT_to_R32G32_FLOAT;
   4553                default:
   4554                    return LUMINANCE_ALPHA32F_EXT_to_default;
   4555            }
   4556        }
   4557        case GL_PALETTE4_R5_G6_B5_OES:
   4558        {
   4559            switch (angleFormat)
   4560            {
   4561                case FormatID::R8G8B8A8_UNORM:
   4562                    return PALETTE4_R5_G6_B5_OES_to_R8G8B8A8_UNORM;
   4563                default:
   4564                    break;
   4565            }
   4566            break;
   4567        }
   4568        case GL_PALETTE4_RGB5_A1_OES:
   4569        {
   4570            switch (angleFormat)
   4571            {
   4572                case FormatID::R8G8B8A8_UNORM:
   4573                    return PALETTE4_RGB5_A1_OES_to_R8G8B8A8_UNORM;
   4574                default:
   4575                    break;
   4576            }
   4577            break;
   4578        }
   4579        case GL_PALETTE4_RGB8_OES:
   4580        {
   4581            switch (angleFormat)
   4582            {
   4583                case FormatID::R8G8B8A8_UNORM:
   4584                    return PALETTE4_RGB8_OES_to_R8G8B8A8_UNORM;
   4585                default:
   4586                    break;
   4587            }
   4588            break;
   4589        }
   4590        case GL_PALETTE4_RGBA4_OES:
   4591        {
   4592            switch (angleFormat)
   4593            {
   4594                case FormatID::R8G8B8A8_UNORM:
   4595                    return PALETTE4_RGBA4_OES_to_R8G8B8A8_UNORM;
   4596                default:
   4597                    break;
   4598            }
   4599            break;
   4600        }
   4601        case GL_PALETTE4_RGBA8_OES:
   4602        {
   4603            switch (angleFormat)
   4604            {
   4605                case FormatID::R8G8B8A8_UNORM:
   4606                    return PALETTE4_RGBA8_OES_to_R8G8B8A8_UNORM;
   4607                default:
   4608                    break;
   4609            }
   4610            break;
   4611        }
   4612        case GL_PALETTE8_R5_G6_B5_OES:
   4613        {
   4614            switch (angleFormat)
   4615            {
   4616                case FormatID::R8G8B8A8_UNORM:
   4617                    return PALETTE8_R5_G6_B5_OES_to_R8G8B8A8_UNORM;
   4618                default:
   4619                    break;
   4620            }
   4621            break;
   4622        }
   4623        case GL_PALETTE8_RGB5_A1_OES:
   4624        {
   4625            switch (angleFormat)
   4626            {
   4627                case FormatID::R8G8B8A8_UNORM:
   4628                    return PALETTE8_RGB5_A1_OES_to_R8G8B8A8_UNORM;
   4629                default:
   4630                    break;
   4631            }
   4632            break;
   4633        }
   4634        case GL_PALETTE8_RGB8_OES:
   4635        {
   4636            switch (angleFormat)
   4637            {
   4638                case FormatID::R8G8B8A8_UNORM:
   4639                    return PALETTE8_RGB8_OES_to_R8G8B8A8_UNORM;
   4640                default:
   4641                    break;
   4642            }
   4643            break;
   4644        }
   4645        case GL_PALETTE8_RGBA4_OES:
   4646        {
   4647            switch (angleFormat)
   4648            {
   4649                case FormatID::R8G8B8A8_UNORM:
   4650                    return PALETTE8_RGBA4_OES_to_R8G8B8A8_UNORM;
   4651                default:
   4652                    break;
   4653            }
   4654            break;
   4655        }
   4656        case GL_PALETTE8_RGBA8_OES:
   4657        {
   4658            switch (angleFormat)
   4659            {
   4660                case FormatID::R8G8B8A8_UNORM:
   4661                    return PALETTE8_RGBA8_OES_to_R8G8B8A8_UNORM;
   4662                default:
   4663                    break;
   4664            }
   4665            break;
   4666        }
   4667        case GL_R11F_G11F_B10F:
   4668        {
   4669            switch (angleFormat)
   4670            {
   4671                case FormatID::R11G11B10_FLOAT:
   4672                    return R11F_G11F_B10F_to_R11G11B10_FLOAT;
   4673                default:
   4674                    break;
   4675            }
   4676            break;
   4677        }
   4678        case GL_R16F:
   4679        {
   4680            switch (angleFormat)
   4681            {
   4682                case FormatID::R16_FLOAT:
   4683                    return R16F_to_R16_FLOAT;
   4684                default:
   4685                    break;
   4686            }
   4687            break;
   4688        }
   4689        case GL_R16I:
   4690        {
   4691            switch (angleFormat)
   4692            {
   4693                case FormatID::R16_SINT:
   4694                    return R16I_to_R16_SINT;
   4695                default:
   4696                    break;
   4697            }
   4698            break;
   4699        }
   4700        case GL_R16UI:
   4701        {
   4702            switch (angleFormat)
   4703            {
   4704                case FormatID::R16_UINT:
   4705                    return R16UI_to_R16_UINT;
   4706                default:
   4707                    break;
   4708            }
   4709            break;
   4710        }
   4711        case GL_R16_EXT:
   4712        {
   4713            switch (angleFormat)
   4714            {
   4715                case FormatID::R16_UNORM:
   4716                    return R16_EXT_to_R16_UNORM;
   4717                default:
   4718                    break;
   4719            }
   4720            break;
   4721        }
   4722        case GL_R16_SNORM_EXT:
   4723        {
   4724            switch (angleFormat)
   4725            {
   4726                case FormatID::R16_SNORM:
   4727                    return R16_SNORM_EXT_to_R16_SNORM;
   4728                default:
   4729                    break;
   4730            }
   4731            break;
   4732        }
   4733        case GL_R16_SSCALED_ANGLEX:
   4734            return R16_SSCALED_ANGLEX_to_default;
   4735        case GL_R16_USCALED_ANGLEX:
   4736            return R16_USCALED_ANGLEX_to_default;
   4737        case GL_R32F:
   4738        {
   4739            switch (angleFormat)
   4740            {
   4741                case FormatID::R32_FLOAT:
   4742                    return R32F_to_R32_FLOAT;
   4743                default:
   4744                    break;
   4745            }
   4746            break;
   4747        }
   4748        case GL_R32I:
   4749        {
   4750            switch (angleFormat)
   4751            {
   4752                case FormatID::R32_SINT:
   4753                    return R32I_to_R32_SINT;
   4754                default:
   4755                    break;
   4756            }
   4757            break;
   4758        }
   4759        case GL_R32UI:
   4760        {
   4761            switch (angleFormat)
   4762            {
   4763                case FormatID::R32_UINT:
   4764                    return R32UI_to_R32_UINT;
   4765                default:
   4766                    break;
   4767            }
   4768            break;
   4769        }
   4770        case GL_R8:
   4771        {
   4772            switch (angleFormat)
   4773            {
   4774                case FormatID::R8_UNORM:
   4775                    return R8_to_R8_UNORM;
   4776                default:
   4777                    break;
   4778            }
   4779            break;
   4780        }
   4781        case GL_R8I:
   4782        {
   4783            switch (angleFormat)
   4784            {
   4785                case FormatID::R8_SINT:
   4786                    return R8I_to_R8_SINT;
   4787                default:
   4788                    break;
   4789            }
   4790            break;
   4791        }
   4792        case GL_R8UI:
   4793        {
   4794            switch (angleFormat)
   4795            {
   4796                case FormatID::R8_UINT:
   4797                    return R8UI_to_R8_UINT;
   4798                default:
   4799                    break;
   4800            }
   4801            break;
   4802        }
   4803        case GL_R8_SNORM:
   4804        {
   4805            switch (angleFormat)
   4806            {
   4807                case FormatID::R8_SNORM:
   4808                    return R8_SNORM_to_R8_SNORM;
   4809                default:
   4810                    break;
   4811            }
   4812            break;
   4813        }
   4814        case GL_R8_SSCALED_ANGLEX:
   4815            return R8_SSCALED_ANGLEX_to_default;
   4816        case GL_R8_USCALED_ANGLEX:
   4817            return R8_USCALED_ANGLEX_to_default;
   4818        case GL_RG16F:
   4819        {
   4820            switch (angleFormat)
   4821            {
   4822                case FormatID::R16G16_FLOAT:
   4823                    return RG16F_to_R16G16_FLOAT;
   4824                default:
   4825                    break;
   4826            }
   4827            break;
   4828        }
   4829        case GL_RG16I:
   4830        {
   4831            switch (angleFormat)
   4832            {
   4833                case FormatID::R16G16_SINT:
   4834                    return RG16I_to_R16G16_SINT;
   4835                default:
   4836                    break;
   4837            }
   4838            break;
   4839        }
   4840        case GL_RG16UI:
   4841        {
   4842            switch (angleFormat)
   4843            {
   4844                case FormatID::R16G16_UINT:
   4845                    return RG16UI_to_R16G16_UINT;
   4846                default:
   4847                    break;
   4848            }
   4849            break;
   4850        }
   4851        case GL_RG16_EXT:
   4852        {
   4853            switch (angleFormat)
   4854            {
   4855                case FormatID::R16G16_UNORM:
   4856                    return RG16_EXT_to_R16G16_UNORM;
   4857                default:
   4858                    break;
   4859            }
   4860            break;
   4861        }
   4862        case GL_RG16_SNORM_EXT:
   4863        {
   4864            switch (angleFormat)
   4865            {
   4866                case FormatID::R16G16_SNORM:
   4867                    return RG16_SNORM_EXT_to_R16G16_SNORM;
   4868                default:
   4869                    break;
   4870            }
   4871            break;
   4872        }
   4873        case GL_RG16_SSCALED_ANGLEX:
   4874            return RG16_SSCALED_ANGLEX_to_default;
   4875        case GL_RG16_USCALED_ANGLEX:
   4876            return RG16_USCALED_ANGLEX_to_default;
   4877        case GL_RG32F:
   4878        {
   4879            switch (angleFormat)
   4880            {
   4881                case FormatID::R32G32_FLOAT:
   4882                    return RG32F_to_R32G32_FLOAT;
   4883                default:
   4884                    break;
   4885            }
   4886            break;
   4887        }
   4888        case GL_RG32I:
   4889        {
   4890            switch (angleFormat)
   4891            {
   4892                case FormatID::R32G32_SINT:
   4893                    return RG32I_to_R32G32_SINT;
   4894                default:
   4895                    break;
   4896            }
   4897            break;
   4898        }
   4899        case GL_RG32UI:
   4900        {
   4901            switch (angleFormat)
   4902            {
   4903                case FormatID::R32G32_UINT:
   4904                    return RG32UI_to_R32G32_UINT;
   4905                default:
   4906                    break;
   4907            }
   4908            break;
   4909        }
   4910        case GL_RG8:
   4911        {
   4912            switch (angleFormat)
   4913            {
   4914                case FormatID::R8G8_UNORM:
   4915                    return RG8_to_R8G8_UNORM;
   4916                default:
   4917                    break;
   4918            }
   4919            break;
   4920        }
   4921        case GL_RG8I:
   4922        {
   4923            switch (angleFormat)
   4924            {
   4925                case FormatID::R8G8_SINT:
   4926                    return RG8I_to_R8G8_SINT;
   4927                default:
   4928                    break;
   4929            }
   4930            break;
   4931        }
   4932        case GL_RG8UI:
   4933        {
   4934            switch (angleFormat)
   4935            {
   4936                case FormatID::R8G8_UINT:
   4937                    return RG8UI_to_R8G8_UINT;
   4938                default:
   4939                    break;
   4940            }
   4941            break;
   4942        }
   4943        case GL_RG8_SNORM:
   4944        {
   4945            switch (angleFormat)
   4946            {
   4947                case FormatID::R8G8_SNORM:
   4948                    return RG8_SNORM_to_R8G8_SNORM;
   4949                default:
   4950                    break;
   4951            }
   4952            break;
   4953        }
   4954        case GL_RG8_SSCALED_ANGLEX:
   4955            return RG8_SSCALED_ANGLEX_to_default;
   4956        case GL_RG8_USCALED_ANGLEX:
   4957            return RG8_USCALED_ANGLEX_to_default;
   4958        case GL_RGB:
   4959            return RGB_to_default;
   4960        case GL_RGB10_A2:
   4961        {
   4962            switch (angleFormat)
   4963            {
   4964                case FormatID::R10G10B10A2_UNORM:
   4965                    return RGB10_A2_to_R10G10B10A2_UNORM;
   4966                default:
   4967                    break;
   4968            }
   4969            break;
   4970        }
   4971        case GL_RGB10_A2UI:
   4972        {
   4973            switch (angleFormat)
   4974            {
   4975                case FormatID::R10G10B10A2_UINT:
   4976                    return RGB10_A2UI_to_R10G10B10A2_UINT;
   4977                default:
   4978                    break;
   4979            }
   4980            break;
   4981        }
   4982        case GL_RGB10_A2_SINT_ANGLEX:
   4983        {
   4984            switch (angleFormat)
   4985            {
   4986                case FormatID::R10G10B10A2_SINT:
   4987                    return RGB10_A2_SINT_ANGLEX_to_R10G10B10A2_SINT;
   4988                default:
   4989                    break;
   4990            }
   4991            break;
   4992        }
   4993        case GL_RGB10_A2_SNORM_ANGLEX:
   4994        {
   4995            switch (angleFormat)
   4996            {
   4997                case FormatID::R10G10B10A2_SNORM:
   4998                    return RGB10_A2_SNORM_ANGLEX_to_R10G10B10A2_SNORM;
   4999                default:
   5000                    break;
   5001            }
   5002            break;
   5003        }
   5004        case GL_RGB10_A2_SSCALED_ANGLEX:
   5005            return RGB10_A2_SSCALED_ANGLEX_to_default;
   5006        case GL_RGB10_A2_USCALED_ANGLEX:
   5007            return RGB10_A2_USCALED_ANGLEX_to_default;
   5008        case GL_RGB10_UNORM_ANGLEX:
   5009        {
   5010            switch (angleFormat)
   5011            {
   5012                case FormatID::R10G10B10A2_UNORM:
   5013                    return RGB10_UNORM_ANGLEX_to_R10G10B10A2_UNORM;
   5014                case FormatID::R10G10B10X2_UNORM:
   5015                    return RGB10_UNORM_ANGLEX_to_R10G10B10X2_UNORM;
   5016                default:
   5017                    break;
   5018            }
   5019            break;
   5020        }
   5021        case GL_RGB16F:
   5022        {
   5023            switch (angleFormat)
   5024            {
   5025                case FormatID::R16G16B16A16_FLOAT:
   5026                    return RGB16F_to_R16G16B16A16_FLOAT;
   5027                case FormatID::R16G16B16_FLOAT:
   5028                    return RGB16F_to_R16G16B16_FLOAT;
   5029                default:
   5030                    break;
   5031            }
   5032            break;
   5033        }
   5034        case GL_RGB16I:
   5035        {
   5036            switch (angleFormat)
   5037            {
   5038                case FormatID::R16G16B16A16_SINT:
   5039                    return RGB16I_to_R16G16B16A16_SINT;
   5040                case FormatID::R16G16B16_SINT:
   5041                    return RGB16I_to_R16G16B16_SINT;
   5042                default:
   5043                    break;
   5044            }
   5045            break;
   5046        }
   5047        case GL_RGB16UI:
   5048        {
   5049            switch (angleFormat)
   5050            {
   5051                case FormatID::R16G16B16A16_UINT:
   5052                    return RGB16UI_to_R16G16B16A16_UINT;
   5053                case FormatID::R16G16B16_UINT:
   5054                    return RGB16UI_to_R16G16B16_UINT;
   5055                default:
   5056                    break;
   5057            }
   5058            break;
   5059        }
   5060        case GL_RGB16_EXT:
   5061        {
   5062            switch (angleFormat)
   5063            {
   5064                case FormatID::R16G16B16A16_UNORM:
   5065                    return RGB16_EXT_to_R16G16B16A16_UNORM;
   5066                case FormatID::R16G16B16_UNORM:
   5067                    return RGB16_EXT_to_R16G16B16_UNORM;
   5068                default:
   5069                    break;
   5070            }
   5071            break;
   5072        }
   5073        case GL_RGB16_SNORM_EXT:
   5074        {
   5075            switch (angleFormat)
   5076            {
   5077                case FormatID::R16G16B16A16_SNORM:
   5078                    return RGB16_SNORM_EXT_to_R16G16B16A16_SNORM;
   5079                case FormatID::R16G16B16_SNORM:
   5080                    return RGB16_SNORM_EXT_to_R16G16B16_SNORM;
   5081                default:
   5082                    break;
   5083            }
   5084            break;
   5085        }
   5086        case GL_RGB16_SSCALED_ANGLEX:
   5087            return RGB16_SSCALED_ANGLEX_to_default;
   5088        case GL_RGB16_USCALED_ANGLEX:
   5089            return RGB16_USCALED_ANGLEX_to_default;
   5090        case GL_RGB32F:
   5091        {
   5092            switch (angleFormat)
   5093            {
   5094                case FormatID::R32G32B32A32_FLOAT:
   5095                    return RGB32F_to_R32G32B32A32_FLOAT;
   5096                case FormatID::R32G32B32_FLOAT:
   5097                    return RGB32F_to_R32G32B32_FLOAT;
   5098                default:
   5099                    break;
   5100            }
   5101            break;
   5102        }
   5103        case GL_RGB32I:
   5104        {
   5105            switch (angleFormat)
   5106            {
   5107                case FormatID::R32G32B32A32_SINT:
   5108                    return RGB32I_to_R32G32B32A32_SINT;
   5109                case FormatID::R32G32B32_SINT:
   5110                    return RGB32I_to_R32G32B32_SINT;
   5111                default:
   5112                    break;
   5113            }
   5114            break;
   5115        }
   5116        case GL_RGB32UI:
   5117        {
   5118            switch (angleFormat)
   5119            {
   5120                case FormatID::R32G32B32A32_UINT:
   5121                    return RGB32UI_to_R32G32B32A32_UINT;
   5122                case FormatID::R32G32B32_UINT:
   5123                    return RGB32UI_to_R32G32B32_UINT;
   5124                default:
   5125                    break;
   5126            }
   5127            break;
   5128        }
   5129        case GL_RGB565:
   5130        {
   5131            switch (angleFormat)
   5132            {
   5133                case FormatID::B5G6R5_UNORM:
   5134                    return RGB565_to_B5G6R5_UNORM;
   5135                case FormatID::R5G6B5_UNORM:
   5136                    return RGB565_to_R5G6B5_UNORM;
   5137                case FormatID::R8G8B8A8_UNORM:
   5138                    return RGB565_to_R8G8B8A8_UNORM;
   5139                default:
   5140                    break;
   5141            }
   5142            break;
   5143        }
   5144        case GL_RGB5_A1:
   5145        {
   5146            switch (angleFormat)
   5147            {
   5148                case FormatID::A1R5G5B5_UNORM:
   5149                    return RGB5_A1_to_A1R5G5B5_UNORM;
   5150                case FormatID::B5G5R5A1_UNORM:
   5151                    return RGB5_A1_to_B5G5R5A1_UNORM;
   5152                case FormatID::R5G5B5A1_UNORM:
   5153                    return RGB5_A1_to_R5G5B5A1_UNORM;
   5154                case FormatID::R8G8B8A8_UNORM:
   5155                    return RGB5_A1_to_R8G8B8A8_UNORM;
   5156                default:
   5157                    break;
   5158            }
   5159            break;
   5160        }
   5161        case GL_RGB8:
   5162        {
   5163            switch (angleFormat)
   5164            {
   5165                case FormatID::R8G8B8A8_UNORM:
   5166                    return RGB8_to_R8G8B8A8_UNORM;
   5167                case FormatID::R8G8B8_UNORM:
   5168                    return RGB8_to_R8G8B8_UNORM;
   5169                default:
   5170                    break;
   5171            }
   5172            break;
   5173        }
   5174        case GL_RGB8I:
   5175        {
   5176            switch (angleFormat)
   5177            {
   5178                case FormatID::R8G8B8A8_SINT:
   5179                    return RGB8I_to_R8G8B8A8_SINT;
   5180                case FormatID::R8G8B8_SINT:
   5181                    return RGB8I_to_R8G8B8_SINT;
   5182                default:
   5183                    break;
   5184            }
   5185            break;
   5186        }
   5187        case GL_RGB8UI:
   5188        {
   5189            switch (angleFormat)
   5190            {
   5191                case FormatID::R8G8B8A8_UINT:
   5192                    return RGB8UI_to_R8G8B8A8_UINT;
   5193                case FormatID::R8G8B8_UINT:
   5194                    return RGB8UI_to_R8G8B8_UINT;
   5195                default:
   5196                    break;
   5197            }
   5198            break;
   5199        }
   5200        case GL_RGB8_SNORM:
   5201        {
   5202            switch (angleFormat)
   5203            {
   5204                case FormatID::R8G8B8A8_SNORM:
   5205                    return RGB8_SNORM_to_R8G8B8A8_SNORM;
   5206                case FormatID::R8G8B8_SNORM:
   5207                    return RGB8_SNORM_to_R8G8B8_SNORM;
   5208                default:
   5209                    break;
   5210            }
   5211            break;
   5212        }
   5213        case GL_RGB8_SSCALED_ANGLEX:
   5214            return RGB8_SSCALED_ANGLEX_to_default;
   5215        case GL_RGB8_USCALED_ANGLEX:
   5216            return RGB8_USCALED_ANGLEX_to_default;
   5217        case GL_RGB9_E5:
   5218        {
   5219            switch (angleFormat)
   5220            {
   5221                case FormatID::R9G9B9E5_SHAREDEXP:
   5222                    return RGB9_E5_to_R9G9B9E5_SHAREDEXP;
   5223                default:
   5224                    break;
   5225            }
   5226            break;
   5227        }
   5228        case GL_RGBA:
   5229            return RGBA_to_default;
   5230        case GL_RGBA16F:
   5231        {
   5232            switch (angleFormat)
   5233            {
   5234                case FormatID::R16G16B16A16_FLOAT:
   5235                    return RGBA16F_to_R16G16B16A16_FLOAT;
   5236                default:
   5237                    break;
   5238            }
   5239            break;
   5240        }
   5241        case GL_RGBA16I:
   5242        {
   5243            switch (angleFormat)
   5244            {
   5245                case FormatID::R16G16B16A16_SINT:
   5246                    return RGBA16I_to_R16G16B16A16_SINT;
   5247                default:
   5248                    break;
   5249            }
   5250            break;
   5251        }
   5252        case GL_RGBA16UI:
   5253        {
   5254            switch (angleFormat)
   5255            {
   5256                case FormatID::R16G16B16A16_UINT:
   5257                    return RGBA16UI_to_R16G16B16A16_UINT;
   5258                default:
   5259                    break;
   5260            }
   5261            break;
   5262        }
   5263        case GL_RGBA16_EXT:
   5264        {
   5265            switch (angleFormat)
   5266            {
   5267                case FormatID::R16G16B16A16_UNORM:
   5268                    return RGBA16_EXT_to_R16G16B16A16_UNORM;
   5269                default:
   5270                    break;
   5271            }
   5272            break;
   5273        }
   5274        case GL_RGBA16_SNORM_EXT:
   5275        {
   5276            switch (angleFormat)
   5277            {
   5278                case FormatID::R16G16B16A16_SNORM:
   5279                    return RGBA16_SNORM_EXT_to_R16G16B16A16_SNORM;
   5280                default:
   5281                    break;
   5282            }
   5283            break;
   5284        }
   5285        case GL_RGBA16_SSCALED_ANGLEX:
   5286            return RGBA16_SSCALED_ANGLEX_to_default;
   5287        case GL_RGBA16_USCALED_ANGLEX:
   5288            return RGBA16_USCALED_ANGLEX_to_default;
   5289        case GL_RGBA32F:
   5290        {
   5291            switch (angleFormat)
   5292            {
   5293                case FormatID::R32G32B32A32_FLOAT:
   5294                    return RGBA32F_to_R32G32B32A32_FLOAT;
   5295                default:
   5296                    break;
   5297            }
   5298            break;
   5299        }
   5300        case GL_RGBA32I:
   5301        {
   5302            switch (angleFormat)
   5303            {
   5304                case FormatID::R32G32B32A32_SINT:
   5305                    return RGBA32I_to_R32G32B32A32_SINT;
   5306                default:
   5307                    break;
   5308            }
   5309            break;
   5310        }
   5311        case GL_RGBA32UI:
   5312        {
   5313            switch (angleFormat)
   5314            {
   5315                case FormatID::R32G32B32A32_UINT:
   5316                    return RGBA32UI_to_R32G32B32A32_UINT;
   5317                default:
   5318                    break;
   5319            }
   5320            break;
   5321        }
   5322        case GL_RGBA4:
   5323        {
   5324            switch (angleFormat)
   5325            {
   5326                case FormatID::B4G4R4A4_UNORM:
   5327                    return RGBA4_to_B4G4R4A4_UNORM;
   5328                case FormatID::R4G4B4A4_UNORM:
   5329                    return RGBA4_to_R4G4B4A4_UNORM;
   5330                case FormatID::R8G8B8A8_UNORM:
   5331                    return RGBA4_to_R8G8B8A8_UNORM;
   5332                default:
   5333                    break;
   5334            }
   5335            break;
   5336        }
   5337        case GL_RGBA8:
   5338        {
   5339            switch (angleFormat)
   5340            {
   5341                case FormatID::R8G8B8A8_UNORM:
   5342                    return RGBA8_to_R8G8B8A8_UNORM;
   5343                default:
   5344                    break;
   5345            }
   5346            break;
   5347        }
   5348        case GL_RGBA8I:
   5349        {
   5350            switch (angleFormat)
   5351            {
   5352                case FormatID::R8G8B8A8_SINT:
   5353                    return RGBA8I_to_R8G8B8A8_SINT;
   5354                default:
   5355                    break;
   5356            }
   5357            break;
   5358        }
   5359        case GL_RGBA8UI:
   5360        {
   5361            switch (angleFormat)
   5362            {
   5363                case FormatID::R8G8B8A8_UINT:
   5364                    return RGBA8UI_to_R8G8B8A8_UINT;
   5365                default:
   5366                    break;
   5367            }
   5368            break;
   5369        }
   5370        case GL_RGBA8_SNORM:
   5371        {
   5372            switch (angleFormat)
   5373            {
   5374                case FormatID::R8G8B8A8_SNORM:
   5375                    return RGBA8_SNORM_to_R8G8B8A8_SNORM;
   5376                default:
   5377                    break;
   5378            }
   5379            break;
   5380        }
   5381        case GL_RGBA8_SSCALED_ANGLEX:
   5382            return RGBA8_SSCALED_ANGLEX_to_default;
   5383        case GL_RGBA8_USCALED_ANGLEX:
   5384            return RGBA8_USCALED_ANGLEX_to_default;
   5385        case GL_RGBX8_ANGLE:
   5386        {
   5387            switch (angleFormat)
   5388            {
   5389                case FormatID::R8G8B8A8_UNORM:
   5390                    return RGBX8_ANGLE_to_R8G8B8A8_UNORM;
   5391                case FormatID::R8G8B8X8_UNORM:
   5392                    return RGBX8_ANGLE_to_R8G8B8X8_UNORM;
   5393                default:
   5394                    break;
   5395            }
   5396            break;
   5397        }
   5398        case GL_SR8_EXT:
   5399        {
   5400            switch (angleFormat)
   5401            {
   5402                case FormatID::R8_UNORM_SRGB:
   5403                    return SR8_EXT_to_R8_UNORM_SRGB;
   5404                default:
   5405                    break;
   5406            }
   5407            break;
   5408        }
   5409        case GL_SRG8_EXT:
   5410        {
   5411            switch (angleFormat)
   5412            {
   5413                case FormatID::R8G8_UNORM_SRGB:
   5414                    return SRG8_EXT_to_R8G8_UNORM_SRGB;
   5415                default:
   5416                    break;
   5417            }
   5418            break;
   5419        }
   5420        case GL_SRGB8:
   5421        {
   5422            switch (angleFormat)
   5423            {
   5424                case FormatID::R8G8B8A8_UNORM_SRGB:
   5425                    return SRGB8_to_R8G8B8A8_UNORM_SRGB;
   5426                case FormatID::R8G8B8_UNORM_SRGB:
   5427                    return SRGB8_to_R8G8B8_UNORM_SRGB;
   5428                default:
   5429                    break;
   5430            }
   5431            break;
   5432        }
   5433        case GL_SRGB8_ALPHA8:
   5434        {
   5435            switch (angleFormat)
   5436            {
   5437                case FormatID::R8G8B8A8_UNORM_SRGB:
   5438                    return SRGB8_ALPHA8_to_R8G8B8A8_UNORM_SRGB;
   5439                default:
   5440                    break;
   5441            }
   5442            break;
   5443        }
   5444        case GL_STENCIL_INDEX8:
   5445        {
   5446            switch (angleFormat)
   5447            {
   5448                case FormatID::S8_UINT:
   5449                    return STENCIL_INDEX8_to_S8_UINT;
   5450                default:
   5451                    return STENCIL_INDEX8_to_default;
   5452            }
   5453        }
   5454 
   5455        default:
   5456            break;
   5457    }
   5458    // clang-format on
   5459    ASSERT(internalFormat == GL_NONE || angleFormat == angle::FormatID::NONE);
   5460    static LoadFunctionMap emptyLoadFunctionsMap;
   5461    return emptyLoadFunctionsMap;
   5462 
   5463 }  // GetLoadFunctionsMap
   5464 
   5465 }  // namespace angle
	tor-browser The Tor Browser
	git clone https://git.dasho.dev/tor-browser.git
	Log \| Files \| Refs \| README \| LICENSE