tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

PackedEnums.cpp (20011B)

      1 // Copyright 2018 The ANGLE Project Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 //
      5 // PackedGLEnums.cpp:
      6 //   Declares ANGLE-specific enums classes for GLEnum and functions operating
      7 //   on them.
      8 
      9 #include "common/PackedEnums.h"
     10 
     11 #include "common/utilities.h"
     12 
     13 namespace gl
     14 {
     15 
     16 TextureType TextureTargetToType(TextureTarget target)
     17 {
     18    switch (target)
     19    {
     20        case TextureTarget::CubeMapNegativeX:
     21        case TextureTarget::CubeMapNegativeY:
     22        case TextureTarget::CubeMapNegativeZ:
     23        case TextureTarget::CubeMapPositiveX:
     24        case TextureTarget::CubeMapPositiveY:
     25        case TextureTarget::CubeMapPositiveZ:
     26            return TextureType::CubeMap;
     27        case TextureTarget::CubeMapArray:
     28            return TextureType::CubeMapArray;
     29        case TextureTarget::External:
     30            return TextureType::External;
     31        case TextureTarget::Rectangle:
     32            return TextureType::Rectangle;
     33        case TextureTarget::_2D:
     34            return TextureType::_2D;
     35        case TextureTarget::_2DArray:
     36            return TextureType::_2DArray;
     37        case TextureTarget::_2DMultisample:
     38            return TextureType::_2DMultisample;
     39        case TextureTarget::_2DMultisampleArray:
     40            return TextureType::_2DMultisampleArray;
     41        case TextureTarget::_3D:
     42            return TextureType::_3D;
     43        case TextureTarget::VideoImage:
     44            return TextureType::VideoImage;
     45        case TextureTarget::Buffer:
     46            return TextureType::Buffer;
     47        case TextureTarget::InvalidEnum:
     48            return TextureType::InvalidEnum;
     49        default:
     50            UNREACHABLE();
     51            return TextureType::InvalidEnum;
     52    }
     53 }
     54 
     55 bool IsCubeMapFaceTarget(TextureTarget target)
     56 {
     57    return TextureTargetToType(target) == TextureType::CubeMap;
     58 }
     59 
     60 TextureTarget NonCubeTextureTypeToTarget(TextureType type)
     61 {
     62    switch (type)
     63    {
     64        case TextureType::External:
     65            return TextureTarget::External;
     66        case TextureType::Rectangle:
     67            return TextureTarget::Rectangle;
     68        case TextureType::_2D:
     69            return TextureTarget::_2D;
     70        case TextureType::_2DArray:
     71            return TextureTarget::_2DArray;
     72        case TextureType::_2DMultisample:
     73            return TextureTarget::_2DMultisample;
     74        case TextureType::_2DMultisampleArray:
     75            return TextureTarget::_2DMultisampleArray;
     76        case TextureType::_3D:
     77            return TextureTarget::_3D;
     78        case TextureType::CubeMapArray:
     79            return TextureTarget::CubeMapArray;
     80        case TextureType::VideoImage:
     81            return TextureTarget::VideoImage;
     82        case TextureType::Buffer:
     83            return TextureTarget::Buffer;
     84        default:
     85            UNREACHABLE();
     86            return TextureTarget::InvalidEnum;
     87    }
     88 }
     89 
     90 // Check that we can do arithmetic on TextureTarget to convert from / to cube map faces
     91 static_assert(static_cast<uint8_t>(TextureTarget::CubeMapNegativeX) -
     92                      static_cast<uint8_t>(TextureTarget::CubeMapPositiveX) ==
     93                  1u,
     94              "");
     95 static_assert(static_cast<uint8_t>(TextureTarget::CubeMapPositiveY) -
     96                      static_cast<uint8_t>(TextureTarget::CubeMapPositiveX) ==
     97                  2u,
     98              "");
     99 static_assert(static_cast<uint8_t>(TextureTarget::CubeMapNegativeY) -
    100                      static_cast<uint8_t>(TextureTarget::CubeMapPositiveX) ==
    101                  3u,
    102              "");
    103 static_assert(static_cast<uint8_t>(TextureTarget::CubeMapPositiveZ) -
    104                      static_cast<uint8_t>(TextureTarget::CubeMapPositiveX) ==
    105                  4u,
    106              "");
    107 static_assert(static_cast<uint8_t>(TextureTarget::CubeMapNegativeZ) -
    108                      static_cast<uint8_t>(TextureTarget::CubeMapPositiveX) ==
    109                  5u,
    110              "");
    111 
    112 TextureTarget CubeFaceIndexToTextureTarget(size_t face)
    113 {
    114    ASSERT(face < 6u);
    115    return static_cast<TextureTarget>(static_cast<uint8_t>(TextureTarget::CubeMapPositiveX) + face);
    116 }
    117 
    118 size_t CubeMapTextureTargetToFaceIndex(TextureTarget target)
    119 {
    120    ASSERT(IsCubeMapFaceTarget(target));
    121    return static_cast<uint8_t>(target) - static_cast<uint8_t>(TextureTarget::CubeMapPositiveX);
    122 }
    123 
    124 TextureType SamplerTypeToTextureType(GLenum samplerType)
    125 {
    126    switch (samplerType)
    127    {
    128        case GL_SAMPLER_2D:
    129        case GL_INT_SAMPLER_2D:
    130        case GL_UNSIGNED_INT_SAMPLER_2D:
    131        case GL_SAMPLER_2D_SHADOW:
    132            return TextureType::_2D;
    133 
    134        case GL_SAMPLER_EXTERNAL_OES:
    135        case GL_SAMPLER_EXTERNAL_2D_Y2Y_EXT:
    136            return TextureType::External;
    137 
    138        case GL_SAMPLER_CUBE:
    139        case GL_INT_SAMPLER_CUBE:
    140        case GL_UNSIGNED_INT_SAMPLER_CUBE:
    141        case GL_SAMPLER_CUBE_SHADOW:
    142            return TextureType::CubeMap;
    143 
    144        case GL_SAMPLER_CUBE_MAP_ARRAY:
    145        case GL_INT_SAMPLER_CUBE_MAP_ARRAY:
    146        case GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY:
    147        case GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW:
    148            return TextureType::CubeMapArray;
    149 
    150        case GL_SAMPLER_2D_ARRAY:
    151        case GL_INT_SAMPLER_2D_ARRAY:
    152        case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
    153        case GL_SAMPLER_2D_ARRAY_SHADOW:
    154            return TextureType::_2DArray;
    155 
    156        case GL_SAMPLER_3D:
    157        case GL_INT_SAMPLER_3D:
    158        case GL_UNSIGNED_INT_SAMPLER_3D:
    159            return TextureType::_3D;
    160 
    161        case GL_SAMPLER_2D_MULTISAMPLE:
    162        case GL_INT_SAMPLER_2D_MULTISAMPLE:
    163        case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE:
    164            return TextureType::_2DMultisample;
    165 
    166        case GL_SAMPLER_2D_MULTISAMPLE_ARRAY:
    167        case GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:
    168        case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:
    169            return TextureType::_2DMultisampleArray;
    170 
    171        case GL_SAMPLER_BUFFER:
    172        case GL_INT_SAMPLER_BUFFER:
    173        case GL_UNSIGNED_INT_SAMPLER_BUFFER:
    174            return TextureType::Buffer;
    175 
    176        case GL_SAMPLER_2D_RECT_ANGLE:
    177            return TextureType::Rectangle;
    178 
    179        case GL_SAMPLER_VIDEO_IMAGE_WEBGL:
    180            return TextureType::VideoImage;
    181 
    182        default:
    183            UNREACHABLE();
    184            return TextureType::InvalidEnum;
    185    }
    186 }
    187 
    188 TextureType ImageTypeToTextureType(GLenum imageType)
    189 {
    190    switch (imageType)
    191    {
    192        case GL_IMAGE_2D:
    193        case GL_INT_IMAGE_2D:
    194        case GL_UNSIGNED_INT_IMAGE_2D:
    195            return TextureType::_2D;
    196 
    197        case GL_IMAGE_CUBE:
    198        case GL_INT_IMAGE_CUBE:
    199        case GL_UNSIGNED_INT_IMAGE_CUBE:
    200            return TextureType::CubeMap;
    201 
    202        case GL_IMAGE_CUBE_MAP_ARRAY:
    203        case GL_INT_IMAGE_CUBE_MAP_ARRAY:
    204        case GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY:
    205            return TextureType::CubeMapArray;
    206 
    207        case GL_IMAGE_2D_ARRAY:
    208        case GL_INT_IMAGE_2D_ARRAY:
    209        case GL_UNSIGNED_INT_IMAGE_2D_ARRAY:
    210            return TextureType::_2DArray;
    211 
    212        case GL_IMAGE_3D:
    213        case GL_INT_IMAGE_3D:
    214        case GL_UNSIGNED_INT_IMAGE_3D:
    215            return TextureType::_3D;
    216 
    217        case GL_IMAGE_BUFFER:
    218        case GL_INT_IMAGE_BUFFER:
    219        case GL_UNSIGNED_INT_IMAGE_BUFFER:
    220            return TextureType::Buffer;
    221 
    222        default:
    223            UNREACHABLE();
    224            return TextureType::InvalidEnum;
    225    }
    226 }
    227 
    228 bool IsMultisampled(TextureType type)
    229 {
    230    switch (type)
    231    {
    232        case TextureType::_2DMultisample:
    233        case TextureType::_2DMultisampleArray:
    234            return true;
    235        default:
    236            return false;
    237    }
    238 }
    239 
    240 bool IsArrayTextureType(TextureType type)
    241 {
    242    switch (type)
    243    {
    244        case TextureType::_2DArray:
    245        case TextureType::_2DMultisampleArray:
    246        case TextureType::CubeMapArray:
    247            return true;
    248        default:
    249            return false;
    250    }
    251 }
    252 
    253 bool IsStaticBufferUsage(BufferUsage useage)
    254 {
    255    switch (useage)
    256    {
    257        case BufferUsage::StaticCopy:
    258        case BufferUsage::StaticDraw:
    259        case BufferUsage::StaticRead:
    260            return true;
    261        default:
    262            return false;
    263    }
    264 }
    265 
    266 std::ostream &operator<<(std::ostream &os, PrimitiveMode value)
    267 {
    268    switch (value)
    269    {
    270        case PrimitiveMode::LineLoop:
    271            os << "GL_LINE_LOOP";
    272            break;
    273        case PrimitiveMode::Lines:
    274            os << "GL_LINES";
    275            break;
    276        case PrimitiveMode::LinesAdjacency:
    277            os << "GL_LINES_ADJACENCY";
    278            break;
    279        case PrimitiveMode::LineStrip:
    280            os << "GL_LINE_STRIP";
    281            break;
    282        case PrimitiveMode::LineStripAdjacency:
    283            os << "GL_LINE_STRIP_ADJANCENCY";
    284            break;
    285        case PrimitiveMode::Patches:
    286            os << "GL_PATCHES";
    287            break;
    288        case PrimitiveMode::Points:
    289            os << "GL_POINTS";
    290            break;
    291        case PrimitiveMode::TriangleFan:
    292            os << "GL_TRIANGLE_FAN";
    293            break;
    294        case PrimitiveMode::Triangles:
    295            os << "GL_TRIANGLES";
    296            break;
    297        case PrimitiveMode::TrianglesAdjacency:
    298            os << "GL_TRIANGLES_ADJANCENCY";
    299            break;
    300        case PrimitiveMode::TriangleStrip:
    301            os << "GL_TRIANGLE_STRIP";
    302            break;
    303        case PrimitiveMode::TriangleStripAdjacency:
    304            os << "GL_TRIANGLE_STRIP_ADJACENCY";
    305            break;
    306        default:
    307            os << "GL_INVALID_ENUM";
    308            break;
    309    }
    310    return os;
    311 }
    312 
    313 std::ostream &operator<<(std::ostream &os, DrawElementsType value)
    314 {
    315    switch (value)
    316    {
    317        case DrawElementsType::UnsignedByte:
    318            os << "GL_UNSIGNED_BYTE";
    319            break;
    320        case DrawElementsType::UnsignedShort:
    321            os << "GL_UNSIGNED_SHORT";
    322            break;
    323        case DrawElementsType::UnsignedInt:
    324            os << "GL_UNSIGNED_INT";
    325            break;
    326        default:
    327            os << "GL_INVALID_ENUM";
    328            break;
    329    }
    330 
    331    return os;
    332 }
    333 
    334 std::ostream &operator<<(std::ostream &os, BlendEquationType value)
    335 {
    336    switch (value)
    337    {
    338        case BlendEquationType::Add:
    339            os << "GL_FUNC_ADD";
    340            break;
    341        case BlendEquationType::Min:
    342            os << "GL_MIN";
    343            break;
    344        case BlendEquationType::Max:
    345            os << "GL_MAX";
    346            break;
    347        case BlendEquationType::Subtract:
    348            os << "GL_FUNC_SUBTRACT";
    349            break;
    350        case BlendEquationType::ReverseSubtract:
    351            os << "GL_FUNC_REVERSE_SUBTRACT";
    352            break;
    353        case BlendEquationType::Multiply:
    354            os << "GL_MULTIPLY_KHR";
    355            break;
    356        case BlendEquationType::Screen:
    357            os << "GL_SCREEN_KHR";
    358            break;
    359        case BlendEquationType::Overlay:
    360            os << "GL_OVERLAY_KHR";
    361            break;
    362        case BlendEquationType::Darken:
    363            os << "GL_DARKEN_KHR";
    364            break;
    365        case BlendEquationType::Lighten:
    366            os << "GL_LIGHTEN_KHR";
    367            break;
    368        case BlendEquationType::Colordodge:
    369            os << "GL_COLORDODGE_KHR";
    370            break;
    371        case BlendEquationType::Colorburn:
    372            os << "GL_COLORBURN_KHR";
    373            break;
    374        case BlendEquationType::Hardlight:
    375            os << "GL_HARDLIGHT_KHR";
    376            break;
    377        case BlendEquationType::Softlight:
    378            os << "GL_SOFTLIGHT_KHR";
    379            break;
    380        case BlendEquationType::Difference:
    381            os << "GL_DIFFERENCE_KHR";
    382            break;
    383        case BlendEquationType::Exclusion:
    384            os << "GL_EXCLUSION_KHR";
    385            break;
    386        case BlendEquationType::HslHue:
    387            os << "GL_HSL_HUE_KHR";
    388            break;
    389        case BlendEquationType::HslSaturation:
    390            os << "GL_HSL_SATURATION_KHR";
    391            break;
    392        case BlendEquationType::HslColor:
    393            os << "GL_HSL_COLOR_KHR";
    394            break;
    395        case BlendEquationType::HslLuminosity:
    396            os << "GL_HSL_LUMINOSITY_KHR";
    397            break;
    398        default:
    399            os << "GL_INVALID_ENUM";
    400            break;
    401    }
    402 
    403    return os;
    404 }
    405 
    406 std::ostream &operator<<(std::ostream &os, BlendFactorType value)
    407 {
    408    switch (value)
    409    {
    410        case BlendFactorType::Zero:
    411            os << "GL_ZERO";
    412            break;
    413        case BlendFactorType::One:
    414            os << "GL_ONE";
    415            break;
    416        case BlendFactorType::SrcColor:
    417            os << "GL_SRC_COLOR";
    418            break;
    419        case BlendFactorType::OneMinusSrcColor:
    420            os << "GL_ONE_MINUS_SRC_COLOR";
    421            break;
    422        case BlendFactorType::SrcAlpha:
    423            os << "GL_SRC_ALPHA";
    424            break;
    425        case BlendFactorType::OneMinusSrcAlpha:
    426            os << "GL_ONE_MINUS_SRC_ALPHA";
    427            break;
    428        case BlendFactorType::DstAlpha:
    429            os << "GL_DST_ALPHA";
    430            break;
    431        case BlendFactorType::OneMinusDstAlpha:
    432            os << "GL_ONE_MINUS_DST_ALPHA";
    433            break;
    434        case BlendFactorType::DstColor:
    435            os << "GL_DST_COLOR";
    436            break;
    437        case BlendFactorType::OneMinusDstColor:
    438            os << "GL_ONE_MINUS_DST_COLOR";
    439            break;
    440        case BlendFactorType::SrcAlphaSaturate:
    441            os << "GL_SRC_ALPHA_SATURATE";
    442            break;
    443        case BlendFactorType::ConstantColor:
    444            os << "GL_CONSTANT_COLOR";
    445            break;
    446        case BlendFactorType::OneMinusConstantColor:
    447            os << "GL_ONE_MINUS_CONSTANT_COLOR";
    448            break;
    449        case BlendFactorType::ConstantAlpha:
    450            os << "GL_CONSTANT_ALPHA";
    451            break;
    452        case BlendFactorType::OneMinusConstantAlpha:
    453            os << "GL_ONE_MINUS_CONSTANT_ALPHA";
    454            break;
    455        case BlendFactorType::Src1Alpha:
    456            os << "GL_SRC1_ALPHA_EXT";
    457            break;
    458        case BlendFactorType::Src1Color:
    459            os << "GL_SRC1_COLOR_EXT";
    460            break;
    461        case BlendFactorType::OneMinusSrc1Color:
    462            os << "GL_ONE_MINUS_SRC1_COLOR_EXT";
    463            break;
    464        case BlendFactorType::OneMinusSrc1Alpha:
    465            os << "GL_ONE_MINUS_SRC1_ALPHA_EXT";
    466            break;
    467        default:
    468            os << "GL_INVALID_ENUM";
    469            break;
    470    }
    471 
    472    return os;
    473 }
    474 
    475 std::ostream &operator<<(std::ostream &os, VertexAttribType value)
    476 {
    477    switch (value)
    478    {
    479        case VertexAttribType::Byte:
    480            os << "GL_BYTE";
    481            break;
    482        case VertexAttribType::Fixed:
    483            os << "GL_FIXED";
    484            break;
    485        case VertexAttribType::Float:
    486            os << "GL_FLOAT";
    487            break;
    488        case VertexAttribType::HalfFloat:
    489            os << "GL_HALF_FLOAT";
    490            break;
    491        case VertexAttribType::HalfFloatOES:
    492            os << "GL_HALF_FLOAT_OES";
    493            break;
    494        case VertexAttribType::Int:
    495            os << "GL_INT";
    496            break;
    497        case VertexAttribType::Int2101010:
    498            os << "GL_INT_2_10_10_10_REV";
    499            break;
    500        case VertexAttribType::Int1010102:
    501            os << "GL_INT_10_10_10_2_OES";
    502            break;
    503        case VertexAttribType::Short:
    504            os << "GL_SHORT";
    505            break;
    506        case VertexAttribType::UnsignedByte:
    507            os << "GL_UNSIGNED_BYTE";
    508            break;
    509        case VertexAttribType::UnsignedInt:
    510            os << "GL_UNSIGNED_INT";
    511            break;
    512        case VertexAttribType::UnsignedInt2101010:
    513            os << "GL_UNSIGNED_INT_2_10_10_10_REV";
    514            break;
    515        case VertexAttribType::UnsignedInt1010102:
    516            os << "GL_UNSIGNED_INT_10_10_10_2_OES";
    517            break;
    518        case VertexAttribType::UnsignedShort:
    519            os << "GL_UNSIGNED_SHORT";
    520            break;
    521        default:
    522            os << "GL_INVALID_ENUM";
    523            break;
    524    }
    525    return os;
    526 }
    527 
    528 std::ostream &operator<<(std::ostream &os, TessEvaluationType value)
    529 {
    530    switch (value)
    531    {
    532        case TessEvaluationType::Triangles:
    533            os << "GL_TRIANGLES";
    534            break;
    535        case TessEvaluationType::Quads:
    536            os << "GL_QUADS";
    537            break;
    538        case TessEvaluationType::Isolines:
    539            os << "GL_ISOLINES";
    540            break;
    541        case TessEvaluationType::EqualSpacing:
    542            os << "GL_EQUAL";
    543            break;
    544        case TessEvaluationType::FractionalEvenSpacing:
    545            os << "GL_FRACTIONAL_EVEN";
    546            break;
    547        case TessEvaluationType::FractionalOddSpacing:
    548            os << "GL_FRACTIONAL_ODD";
    549            break;
    550        case TessEvaluationType::Cw:
    551            os << "GL_CW";
    552            break;
    553        case TessEvaluationType::Ccw:
    554            os << "GL_CCW";
    555            break;
    556        case TessEvaluationType::PointMode:
    557            os << "GL_TESS_GEN_POINT_MODE";
    558            break;
    559        default:
    560            os << "GL_INVALID_ENUM";
    561            break;
    562    }
    563    return os;
    564 }
    565 
    566 const char *ShaderTypeToString(ShaderType shaderType)
    567 {
    568    constexpr ShaderMap<const char *> kShaderTypeNameMap = {
    569        {ShaderType::Vertex, "Vertex"},
    570        {ShaderType::TessControl, "Tessellation control"},
    571        {ShaderType::TessEvaluation, "Tessellation evaluation"},
    572        {ShaderType::Geometry, "Geometry"},
    573        {ShaderType::Fragment, "Fragment"},
    574        {ShaderType::Compute, "Compute"}};
    575    return kShaderTypeNameMap[shaderType];
    576 }
    577 
    578 bool operator<(const UniformLocation &lhs, const UniformLocation &rhs)
    579 {
    580    return lhs.value < rhs.value;
    581 }
    582 
    583 bool IsEmulatedCompressedFormat(GLenum format)
    584 {
    585    // TODO(anglebug.com/6177): Check for all formats ANGLE will use to emulate a compressed texture
    586    return format == GL_RGBA || format == GL_RG || format == GL_RED;
    587 }
    588 }  // namespace gl
    589 
    590 namespace egl
    591 {
    592 MessageType ErrorCodeToMessageType(EGLint errorCode)
    593 {
    594    switch (errorCode)
    595    {
    596        case EGL_BAD_ALLOC:
    597        case EGL_CONTEXT_LOST:
    598        case EGL_NOT_INITIALIZED:
    599            return MessageType::Critical;
    600 
    601        case EGL_BAD_ACCESS:
    602        case EGL_BAD_ATTRIBUTE:
    603        case EGL_BAD_CONFIG:
    604        case EGL_BAD_CONTEXT:
    605        case EGL_BAD_CURRENT_SURFACE:
    606        case EGL_BAD_DISPLAY:
    607        case EGL_BAD_MATCH:
    608        case EGL_BAD_NATIVE_PIXMAP:
    609        case EGL_BAD_NATIVE_WINDOW:
    610        case EGL_BAD_PARAMETER:
    611        case EGL_BAD_SURFACE:
    612        case EGL_BAD_STREAM_KHR:
    613        case EGL_BAD_STATE_KHR:
    614        case EGL_BAD_DEVICE_EXT:
    615            return MessageType::Error;
    616 
    617        case EGL_SUCCESS:
    618        default:
    619            UNREACHABLE();
    620            return MessageType::InvalidEnum;
    621    }
    622 }
    623 }  // namespace egl
    624 
    625 namespace egl_gl
    626 {
    627 
    628 gl::TextureTarget EGLCubeMapTargetToCubeMapTarget(EGLenum eglTarget)
    629 {
    630    ASSERT(egl::IsCubeMapTextureTarget(eglTarget));
    631    return gl::CubeFaceIndexToTextureTarget(egl::CubeMapTextureTargetToLayerIndex(eglTarget));
    632 }
    633 
    634 gl::TextureTarget EGLImageTargetToTextureTarget(EGLenum eglTarget)
    635 {
    636    switch (eglTarget)
    637    {
    638        case EGL_GL_TEXTURE_2D_KHR:
    639            return gl::TextureTarget::_2D;
    640 
    641        case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR:
    642        case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X_KHR:
    643        case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y_KHR:
    644        case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_KHR:
    645        case EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z_KHR:
    646        case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_KHR:
    647            return EGLCubeMapTargetToCubeMapTarget(eglTarget);
    648 
    649        case EGL_GL_TEXTURE_3D_KHR:
    650            return gl::TextureTarget::_3D;
    651 
    652        default:
    653            UNREACHABLE();
    654            return gl::TextureTarget::InvalidEnum;
    655    }
    656 }
    657 
    658 gl::TextureType EGLTextureTargetToTextureType(EGLenum eglTarget)
    659 {
    660    switch (eglTarget)
    661    {
    662        case EGL_TEXTURE_2D:
    663            return gl::TextureType::_2D;
    664 
    665        case EGL_TEXTURE_RECTANGLE_ANGLE:
    666            return gl::TextureType::Rectangle;
    667 
    668        default:
    669            UNREACHABLE();
    670            return gl::TextureType::InvalidEnum;
    671    }
    672 }
    673 }  // namespace egl_gl