[ tor-browser ].git.dasho

PackedGLEnums_autogen.cpp (69784B)
      1 // GENERATED FILE - DO NOT EDIT.
      2 // Generated by gen_packed_gl_enums.py using data from packed_gl_enums.json.
      3 //
      4 // Copyright 2017 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 // PackedGLEnums_autogen.cpp:
      9 //   Implements ANGLE-specific enums classes for GLenums and functions operating
     10 //   on them.
     11 
     12 #include "common/PackedGLEnums_autogen.h"
     13 #include "common/debug.h"
     14 
     15 namespace gl
     16 {
     17 
     18 template <>
     19 AlphaTestFunc FromGLenum<AlphaTestFunc>(GLenum from)
     20 {
     21    switch (from)
     22    {
     23        case GL_ALWAYS:
     24            return AlphaTestFunc::AlwaysPass;
     25        case GL_EQUAL:
     26            return AlphaTestFunc::Equal;
     27        case GL_GEQUAL:
     28            return AlphaTestFunc::Gequal;
     29        case GL_GREATER:
     30            return AlphaTestFunc::Greater;
     31        case GL_LEQUAL:
     32            return AlphaTestFunc::Lequal;
     33        case GL_LESS:
     34            return AlphaTestFunc::Less;
     35        case GL_NEVER:
     36            return AlphaTestFunc::Never;
     37        case GL_NOTEQUAL:
     38            return AlphaTestFunc::NotEqual;
     39        default:
     40            return AlphaTestFunc::InvalidEnum;
     41    }
     42 }
     43 
     44 GLenum ToGLenum(AlphaTestFunc from)
     45 {
     46    switch (from)
     47    {
     48        case AlphaTestFunc::AlwaysPass:
     49            return GL_ALWAYS;
     50        case AlphaTestFunc::Equal:
     51            return GL_EQUAL;
     52        case AlphaTestFunc::Gequal:
     53            return GL_GEQUAL;
     54        case AlphaTestFunc::Greater:
     55            return GL_GREATER;
     56        case AlphaTestFunc::Lequal:
     57            return GL_LEQUAL;
     58        case AlphaTestFunc::Less:
     59            return GL_LESS;
     60        case AlphaTestFunc::Never:
     61            return GL_NEVER;
     62        case AlphaTestFunc::NotEqual:
     63            return GL_NOTEQUAL;
     64        default:
     65            UNREACHABLE();
     66            return 0;
     67    }
     68 }
     69 
     70 std::ostream &operator<<(std::ostream &os, AlphaTestFunc value)
     71 {
     72    switch (value)
     73    {
     74        case AlphaTestFunc::AlwaysPass:
     75            os << "GL_ALWAYS";
     76            break;
     77        case AlphaTestFunc::Equal:
     78            os << "GL_EQUAL";
     79            break;
     80        case AlphaTestFunc::Gequal:
     81            os << "GL_GEQUAL";
     82            break;
     83        case AlphaTestFunc::Greater:
     84            os << "GL_GREATER";
     85            break;
     86        case AlphaTestFunc::Lequal:
     87            os << "GL_LEQUAL";
     88            break;
     89        case AlphaTestFunc::Less:
     90            os << "GL_LESS";
     91            break;
     92        case AlphaTestFunc::Never:
     93            os << "GL_NEVER";
     94            break;
     95        case AlphaTestFunc::NotEqual:
     96            os << "GL_NOTEQUAL";
     97            break;
     98        default:
     99            os << "GL_INVALID_ENUM";
    100            break;
    101    }
    102    return os;
    103 }
    104 
    105 template <>
    106 BufferBinding FromGLenum<BufferBinding>(GLenum from)
    107 {
    108    switch (from)
    109    {
    110        case GL_ARRAY_BUFFER:
    111            return BufferBinding::Array;
    112        case GL_ATOMIC_COUNTER_BUFFER:
    113            return BufferBinding::AtomicCounter;
    114        case GL_COPY_READ_BUFFER:
    115            return BufferBinding::CopyRead;
    116        case GL_COPY_WRITE_BUFFER:
    117            return BufferBinding::CopyWrite;
    118        case GL_DISPATCH_INDIRECT_BUFFER:
    119            return BufferBinding::DispatchIndirect;
    120        case GL_DRAW_INDIRECT_BUFFER:
    121            return BufferBinding::DrawIndirect;
    122        case GL_ELEMENT_ARRAY_BUFFER:
    123            return BufferBinding::ElementArray;
    124        case GL_PIXEL_PACK_BUFFER:
    125            return BufferBinding::PixelPack;
    126        case GL_PIXEL_UNPACK_BUFFER:
    127            return BufferBinding::PixelUnpack;
    128        case GL_SHADER_STORAGE_BUFFER:
    129            return BufferBinding::ShaderStorage;
    130        case GL_TEXTURE_BUFFER:
    131            return BufferBinding::Texture;
    132        case GL_TRANSFORM_FEEDBACK_BUFFER:
    133            return BufferBinding::TransformFeedback;
    134        case GL_UNIFORM_BUFFER:
    135            return BufferBinding::Uniform;
    136        default:
    137            return BufferBinding::InvalidEnum;
    138    }
    139 }
    140 
    141 GLenum ToGLenum(BufferBinding from)
    142 {
    143    switch (from)
    144    {
    145        case BufferBinding::Array:
    146            return GL_ARRAY_BUFFER;
    147        case BufferBinding::AtomicCounter:
    148            return GL_ATOMIC_COUNTER_BUFFER;
    149        case BufferBinding::CopyRead:
    150            return GL_COPY_READ_BUFFER;
    151        case BufferBinding::CopyWrite:
    152            return GL_COPY_WRITE_BUFFER;
    153        case BufferBinding::DispatchIndirect:
    154            return GL_DISPATCH_INDIRECT_BUFFER;
    155        case BufferBinding::DrawIndirect:
    156            return GL_DRAW_INDIRECT_BUFFER;
    157        case BufferBinding::ElementArray:
    158            return GL_ELEMENT_ARRAY_BUFFER;
    159        case BufferBinding::PixelPack:
    160            return GL_PIXEL_PACK_BUFFER;
    161        case BufferBinding::PixelUnpack:
    162            return GL_PIXEL_UNPACK_BUFFER;
    163        case BufferBinding::ShaderStorage:
    164            return GL_SHADER_STORAGE_BUFFER;
    165        case BufferBinding::Texture:
    166            return GL_TEXTURE_BUFFER;
    167        case BufferBinding::TransformFeedback:
    168            return GL_TRANSFORM_FEEDBACK_BUFFER;
    169        case BufferBinding::Uniform:
    170            return GL_UNIFORM_BUFFER;
    171        default:
    172            UNREACHABLE();
    173            return 0;
    174    }
    175 }
    176 
    177 std::ostream &operator<<(std::ostream &os, BufferBinding value)
    178 {
    179    switch (value)
    180    {
    181        case BufferBinding::Array:
    182            os << "GL_ARRAY_BUFFER";
    183            break;
    184        case BufferBinding::AtomicCounter:
    185            os << "GL_ATOMIC_COUNTER_BUFFER";
    186            break;
    187        case BufferBinding::CopyRead:
    188            os << "GL_COPY_READ_BUFFER";
    189            break;
    190        case BufferBinding::CopyWrite:
    191            os << "GL_COPY_WRITE_BUFFER";
    192            break;
    193        case BufferBinding::DispatchIndirect:
    194            os << "GL_DISPATCH_INDIRECT_BUFFER";
    195            break;
    196        case BufferBinding::DrawIndirect:
    197            os << "GL_DRAW_INDIRECT_BUFFER";
    198            break;
    199        case BufferBinding::ElementArray:
    200            os << "GL_ELEMENT_ARRAY_BUFFER";
    201            break;
    202        case BufferBinding::PixelPack:
    203            os << "GL_PIXEL_PACK_BUFFER";
    204            break;
    205        case BufferBinding::PixelUnpack:
    206            os << "GL_PIXEL_UNPACK_BUFFER";
    207            break;
    208        case BufferBinding::ShaderStorage:
    209            os << "GL_SHADER_STORAGE_BUFFER";
    210            break;
    211        case BufferBinding::Texture:
    212            os << "GL_TEXTURE_BUFFER";
    213            break;
    214        case BufferBinding::TransformFeedback:
    215            os << "GL_TRANSFORM_FEEDBACK_BUFFER";
    216            break;
    217        case BufferBinding::Uniform:
    218            os << "GL_UNIFORM_BUFFER";
    219            break;
    220        default:
    221            os << "GL_INVALID_ENUM";
    222            break;
    223    }
    224    return os;
    225 }
    226 
    227 template <>
    228 BufferUsage FromGLenum<BufferUsage>(GLenum from)
    229 {
    230    switch (from)
    231    {
    232        case GL_DYNAMIC_COPY:
    233            return BufferUsage::DynamicCopy;
    234        case GL_DYNAMIC_DRAW:
    235            return BufferUsage::DynamicDraw;
    236        case GL_DYNAMIC_READ:
    237            return BufferUsage::DynamicRead;
    238        case GL_STATIC_COPY:
    239            return BufferUsage::StaticCopy;
    240        case GL_STATIC_DRAW:
    241            return BufferUsage::StaticDraw;
    242        case GL_STATIC_READ:
    243            return BufferUsage::StaticRead;
    244        case GL_STREAM_COPY:
    245            return BufferUsage::StreamCopy;
    246        case GL_STREAM_DRAW:
    247            return BufferUsage::StreamDraw;
    248        case GL_STREAM_READ:
    249            return BufferUsage::StreamRead;
    250        default:
    251            return BufferUsage::InvalidEnum;
    252    }
    253 }
    254 
    255 GLenum ToGLenum(BufferUsage from)
    256 {
    257    switch (from)
    258    {
    259        case BufferUsage::DynamicCopy:
    260            return GL_DYNAMIC_COPY;
    261        case BufferUsage::DynamicDraw:
    262            return GL_DYNAMIC_DRAW;
    263        case BufferUsage::DynamicRead:
    264            return GL_DYNAMIC_READ;
    265        case BufferUsage::StaticCopy:
    266            return GL_STATIC_COPY;
    267        case BufferUsage::StaticDraw:
    268            return GL_STATIC_DRAW;
    269        case BufferUsage::StaticRead:
    270            return GL_STATIC_READ;
    271        case BufferUsage::StreamCopy:
    272            return GL_STREAM_COPY;
    273        case BufferUsage::StreamDraw:
    274            return GL_STREAM_DRAW;
    275        case BufferUsage::StreamRead:
    276            return GL_STREAM_READ;
    277        default:
    278            UNREACHABLE();
    279            return 0;
    280    }
    281 }
    282 
    283 std::ostream &operator<<(std::ostream &os, BufferUsage value)
    284 {
    285    switch (value)
    286    {
    287        case BufferUsage::DynamicCopy:
    288            os << "GL_DYNAMIC_COPY";
    289            break;
    290        case BufferUsage::DynamicDraw:
    291            os << "GL_DYNAMIC_DRAW";
    292            break;
    293        case BufferUsage::DynamicRead:
    294            os << "GL_DYNAMIC_READ";
    295            break;
    296        case BufferUsage::StaticCopy:
    297            os << "GL_STATIC_COPY";
    298            break;
    299        case BufferUsage::StaticDraw:
    300            os << "GL_STATIC_DRAW";
    301            break;
    302        case BufferUsage::StaticRead:
    303            os << "GL_STATIC_READ";
    304            break;
    305        case BufferUsage::StreamCopy:
    306            os << "GL_STREAM_COPY";
    307            break;
    308        case BufferUsage::StreamDraw:
    309            os << "GL_STREAM_DRAW";
    310            break;
    311        case BufferUsage::StreamRead:
    312            os << "GL_STREAM_READ";
    313            break;
    314        default:
    315            os << "GL_INVALID_ENUM";
    316            break;
    317    }
    318    return os;
    319 }
    320 
    321 template <>
    322 ClientVertexArrayType FromGLenum<ClientVertexArrayType>(GLenum from)
    323 {
    324    switch (from)
    325    {
    326        case GL_COLOR_ARRAY:
    327            return ClientVertexArrayType::Color;
    328        case GL_NORMAL_ARRAY:
    329            return ClientVertexArrayType::Normal;
    330        case GL_POINT_SIZE_ARRAY_OES:
    331            return ClientVertexArrayType::PointSize;
    332        case GL_TEXTURE_COORD_ARRAY:
    333            return ClientVertexArrayType::TextureCoord;
    334        case GL_VERTEX_ARRAY:
    335            return ClientVertexArrayType::Vertex;
    336        default:
    337            return ClientVertexArrayType::InvalidEnum;
    338    }
    339 }
    340 
    341 GLenum ToGLenum(ClientVertexArrayType from)
    342 {
    343    switch (from)
    344    {
    345        case ClientVertexArrayType::Color:
    346            return GL_COLOR_ARRAY;
    347        case ClientVertexArrayType::Normal:
    348            return GL_NORMAL_ARRAY;
    349        case ClientVertexArrayType::PointSize:
    350            return GL_POINT_SIZE_ARRAY_OES;
    351        case ClientVertexArrayType::TextureCoord:
    352            return GL_TEXTURE_COORD_ARRAY;
    353        case ClientVertexArrayType::Vertex:
    354            return GL_VERTEX_ARRAY;
    355        default:
    356            UNREACHABLE();
    357            return 0;
    358    }
    359 }
    360 
    361 std::ostream &operator<<(std::ostream &os, ClientVertexArrayType value)
    362 {
    363    switch (value)
    364    {
    365        case ClientVertexArrayType::Color:
    366            os << "GL_COLOR_ARRAY";
    367            break;
    368        case ClientVertexArrayType::Normal:
    369            os << "GL_NORMAL_ARRAY";
    370            break;
    371        case ClientVertexArrayType::PointSize:
    372            os << "GL_POINT_SIZE_ARRAY_OES";
    373            break;
    374        case ClientVertexArrayType::TextureCoord:
    375            os << "GL_TEXTURE_COORD_ARRAY";
    376            break;
    377        case ClientVertexArrayType::Vertex:
    378            os << "GL_VERTEX_ARRAY";
    379            break;
    380        default:
    381            os << "GL_INVALID_ENUM";
    382            break;
    383    }
    384    return os;
    385 }
    386 
    387 template <>
    388 CullFaceMode FromGLenum<CullFaceMode>(GLenum from)
    389 {
    390    switch (from)
    391    {
    392        case GL_BACK:
    393            return CullFaceMode::Back;
    394        case GL_FRONT:
    395            return CullFaceMode::Front;
    396        case GL_FRONT_AND_BACK:
    397            return CullFaceMode::FrontAndBack;
    398        default:
    399            return CullFaceMode::InvalidEnum;
    400    }
    401 }
    402 
    403 GLenum ToGLenum(CullFaceMode from)
    404 {
    405    switch (from)
    406    {
    407        case CullFaceMode::Back:
    408            return GL_BACK;
    409        case CullFaceMode::Front:
    410            return GL_FRONT;
    411        case CullFaceMode::FrontAndBack:
    412            return GL_FRONT_AND_BACK;
    413        default:
    414            UNREACHABLE();
    415            return 0;
    416    }
    417 }
    418 
    419 std::ostream &operator<<(std::ostream &os, CullFaceMode value)
    420 {
    421    switch (value)
    422    {
    423        case CullFaceMode::Back:
    424            os << "GL_BACK";
    425            break;
    426        case CullFaceMode::Front:
    427            os << "GL_FRONT";
    428            break;
    429        case CullFaceMode::FrontAndBack:
    430            os << "GL_FRONT_AND_BACK";
    431            break;
    432        default:
    433            os << "GL_INVALID_ENUM";
    434            break;
    435    }
    436    return os;
    437 }
    438 
    439 template <>
    440 FilterMode FromGLenum<FilterMode>(GLenum from)
    441 {
    442    switch (from)
    443    {
    444        case GL_NEAREST:
    445            return FilterMode::Nearest;
    446        case GL_LINEAR:
    447            return FilterMode::Linear;
    448        case GL_NEAREST_MIPMAP_NEAREST:
    449            return FilterMode::NearestMipmapNearest;
    450        case GL_NEAREST_MIPMAP_LINEAR:
    451            return FilterMode::NearestMipmapLinear;
    452        case GL_LINEAR_MIPMAP_LINEAR:
    453            return FilterMode::LinearMipmapLinear;
    454        default:
    455            return FilterMode::InvalidEnum;
    456    }
    457 }
    458 
    459 GLenum ToGLenum(FilterMode from)
    460 {
    461    switch (from)
    462    {
    463        case FilterMode::Nearest:
    464            return GL_NEAREST;
    465        case FilterMode::Linear:
    466            return GL_LINEAR;
    467        case FilterMode::NearestMipmapNearest:
    468            return GL_NEAREST_MIPMAP_NEAREST;
    469        case FilterMode::NearestMipmapLinear:
    470            return GL_NEAREST_MIPMAP_LINEAR;
    471        case FilterMode::LinearMipmapLinear:
    472            return GL_LINEAR_MIPMAP_LINEAR;
    473        default:
    474            UNREACHABLE();
    475            return 0;
    476    }
    477 }
    478 
    479 std::ostream &operator<<(std::ostream &os, FilterMode value)
    480 {
    481    switch (value)
    482    {
    483        case FilterMode::Nearest:
    484            os << "GL_NEAREST";
    485            break;
    486        case FilterMode::Linear:
    487            os << "GL_LINEAR";
    488            break;
    489        case FilterMode::NearestMipmapNearest:
    490            os << "GL_NEAREST_MIPMAP_NEAREST";
    491            break;
    492        case FilterMode::NearestMipmapLinear:
    493            os << "GL_NEAREST_MIPMAP_LINEAR";
    494            break;
    495        case FilterMode::LinearMipmapLinear:
    496            os << "GL_LINEAR_MIPMAP_LINEAR";
    497            break;
    498        default:
    499            os << "GL_INVALID_ENUM";
    500            break;
    501    }
    502    return os;
    503 }
    504 
    505 template <>
    506 FogMode FromGLenum<FogMode>(GLenum from)
    507 {
    508    switch (from)
    509    {
    510        case GL_EXP:
    511            return FogMode::Exp;
    512        case GL_EXP2:
    513            return FogMode::Exp2;
    514        case GL_LINEAR:
    515            return FogMode::Linear;
    516        default:
    517            return FogMode::InvalidEnum;
    518    }
    519 }
    520 
    521 GLenum ToGLenum(FogMode from)
    522 {
    523    switch (from)
    524    {
    525        case FogMode::Exp:
    526            return GL_EXP;
    527        case FogMode::Exp2:
    528            return GL_EXP2;
    529        case FogMode::Linear:
    530            return GL_LINEAR;
    531        default:
    532            UNREACHABLE();
    533            return 0;
    534    }
    535 }
    536 
    537 std::ostream &operator<<(std::ostream &os, FogMode value)
    538 {
    539    switch (value)
    540    {
    541        case FogMode::Exp:
    542            os << "GL_EXP";
    543            break;
    544        case FogMode::Exp2:
    545            os << "GL_EXP2";
    546            break;
    547        case FogMode::Linear:
    548            os << "GL_LINEAR";
    549            break;
    550        default:
    551            os << "GL_INVALID_ENUM";
    552            break;
    553    }
    554    return os;
    555 }
    556 
    557 template <>
    558 GraphicsResetStatus FromGLenum<GraphicsResetStatus>(GLenum from)
    559 {
    560    switch (from)
    561    {
    562        case GL_NO_ERROR:
    563            return GraphicsResetStatus::NoError;
    564        case GL_GUILTY_CONTEXT_RESET:
    565            return GraphicsResetStatus::GuiltyContextReset;
    566        case GL_INNOCENT_CONTEXT_RESET:
    567            return GraphicsResetStatus::InnocentContextReset;
    568        case GL_UNKNOWN_CONTEXT_RESET:
    569            return GraphicsResetStatus::UnknownContextReset;
    570        case GL_PURGED_CONTEXT_RESET_NV:
    571            return GraphicsResetStatus::PurgedContextResetNV;
    572        default:
    573            return GraphicsResetStatus::InvalidEnum;
    574    }
    575 }
    576 
    577 GLenum ToGLenum(GraphicsResetStatus from)
    578 {
    579    switch (from)
    580    {
    581        case GraphicsResetStatus::NoError:
    582            return GL_NO_ERROR;
    583        case GraphicsResetStatus::GuiltyContextReset:
    584            return GL_GUILTY_CONTEXT_RESET;
    585        case GraphicsResetStatus::InnocentContextReset:
    586            return GL_INNOCENT_CONTEXT_RESET;
    587        case GraphicsResetStatus::UnknownContextReset:
    588            return GL_UNKNOWN_CONTEXT_RESET;
    589        case GraphicsResetStatus::PurgedContextResetNV:
    590            return GL_PURGED_CONTEXT_RESET_NV;
    591        default:
    592            UNREACHABLE();
    593            return 0;
    594    }
    595 }
    596 
    597 std::ostream &operator<<(std::ostream &os, GraphicsResetStatus value)
    598 {
    599    switch (value)
    600    {
    601        case GraphicsResetStatus::NoError:
    602            os << "GL_NO_ERROR";
    603            break;
    604        case GraphicsResetStatus::GuiltyContextReset:
    605            os << "GL_GUILTY_CONTEXT_RESET";
    606            break;
    607        case GraphicsResetStatus::InnocentContextReset:
    608            os << "GL_INNOCENT_CONTEXT_RESET";
    609            break;
    610        case GraphicsResetStatus::UnknownContextReset:
    611            os << "GL_UNKNOWN_CONTEXT_RESET";
    612            break;
    613        case GraphicsResetStatus::PurgedContextResetNV:
    614            os << "GL_PURGED_CONTEXT_RESET_NV";
    615            break;
    616        default:
    617            os << "GL_INVALID_ENUM";
    618            break;
    619    }
    620    return os;
    621 }
    622 
    623 template <>
    624 HandleType FromGLenum<HandleType>(GLenum from)
    625 {
    626    switch (from)
    627    {
    628        case GL_HANDLE_TYPE_OPAQUE_FD_EXT:
    629            return HandleType::OpaqueFd;
    630        case GL_HANDLE_TYPE_ZIRCON_VMO_ANGLE:
    631            return HandleType::ZirconVmo;
    632        case GL_HANDLE_TYPE_ZIRCON_EVENT_ANGLE:
    633            return HandleType::ZirconEvent;
    634        default:
    635            return HandleType::InvalidEnum;
    636    }
    637 }
    638 
    639 GLenum ToGLenum(HandleType from)
    640 {
    641    switch (from)
    642    {
    643        case HandleType::OpaqueFd:
    644            return GL_HANDLE_TYPE_OPAQUE_FD_EXT;
    645        case HandleType::ZirconVmo:
    646            return GL_HANDLE_TYPE_ZIRCON_VMO_ANGLE;
    647        case HandleType::ZirconEvent:
    648            return GL_HANDLE_TYPE_ZIRCON_EVENT_ANGLE;
    649        default:
    650            UNREACHABLE();
    651            return 0;
    652    }
    653 }
    654 
    655 std::ostream &operator<<(std::ostream &os, HandleType value)
    656 {
    657    switch (value)
    658    {
    659        case HandleType::OpaqueFd:
    660            os << "GL_HANDLE_TYPE_OPAQUE_FD_EXT";
    661            break;
    662        case HandleType::ZirconVmo:
    663            os << "GL_HANDLE_TYPE_ZIRCON_VMO_ANGLE";
    664            break;
    665        case HandleType::ZirconEvent:
    666            os << "GL_HANDLE_TYPE_ZIRCON_EVENT_ANGLE";
    667            break;
    668        default:
    669            os << "GL_INVALID_ENUM";
    670            break;
    671    }
    672    return os;
    673 }
    674 
    675 template <>
    676 HintSetting FromGLenum<HintSetting>(GLenum from)
    677 {
    678    switch (from)
    679    {
    680        case GL_DONT_CARE:
    681            return HintSetting::DontCare;
    682        case GL_FASTEST:
    683            return HintSetting::Fastest;
    684        case GL_NICEST:
    685            return HintSetting::Nicest;
    686        default:
    687            return HintSetting::InvalidEnum;
    688    }
    689 }
    690 
    691 GLenum ToGLenum(HintSetting from)
    692 {
    693    switch (from)
    694    {
    695        case HintSetting::DontCare:
    696            return GL_DONT_CARE;
    697        case HintSetting::Fastest:
    698            return GL_FASTEST;
    699        case HintSetting::Nicest:
    700            return GL_NICEST;
    701        default:
    702            UNREACHABLE();
    703            return 0;
    704    }
    705 }
    706 
    707 std::ostream &operator<<(std::ostream &os, HintSetting value)
    708 {
    709    switch (value)
    710    {
    711        case HintSetting::DontCare:
    712            os << "GL_DONT_CARE";
    713            break;
    714        case HintSetting::Fastest:
    715            os << "GL_FASTEST";
    716            break;
    717        case HintSetting::Nicest:
    718            os << "GL_NICEST";
    719            break;
    720        default:
    721            os << "GL_INVALID_ENUM";
    722            break;
    723    }
    724    return os;
    725 }
    726 
    727 template <>
    728 ImageLayout FromGLenum<ImageLayout>(GLenum from)
    729 {
    730    switch (from)
    731    {
    732        case GL_NONE:
    733            return ImageLayout::Undefined;
    734        case GL_LAYOUT_GENERAL_EXT:
    735            return ImageLayout::General;
    736        case GL_LAYOUT_COLOR_ATTACHMENT_EXT:
    737            return ImageLayout::ColorAttachment;
    738        case GL_LAYOUT_DEPTH_STENCIL_ATTACHMENT_EXT:
    739            return ImageLayout::DepthStencilAttachment;
    740        case GL_LAYOUT_DEPTH_STENCIL_READ_ONLY_EXT:
    741            return ImageLayout::DepthStencilReadOnlyAttachment;
    742        case GL_LAYOUT_SHADER_READ_ONLY_EXT:
    743            return ImageLayout::ShaderReadOnly;
    744        case GL_LAYOUT_TRANSFER_SRC_EXT:
    745            return ImageLayout::TransferSrc;
    746        case GL_LAYOUT_TRANSFER_DST_EXT:
    747            return ImageLayout::TransferDst;
    748        case GL_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_EXT:
    749            return ImageLayout::DepthReadOnlyStencilAttachment;
    750        case GL_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_EXT:
    751            return ImageLayout::DepthAttachmentStencilReadOnly;
    752        default:
    753            return ImageLayout::InvalidEnum;
    754    }
    755 }
    756 
    757 GLenum ToGLenum(ImageLayout from)
    758 {
    759    switch (from)
    760    {
    761        case ImageLayout::Undefined:
    762            return GL_NONE;
    763        case ImageLayout::General:
    764            return GL_LAYOUT_GENERAL_EXT;
    765        case ImageLayout::ColorAttachment:
    766            return GL_LAYOUT_COLOR_ATTACHMENT_EXT;
    767        case ImageLayout::DepthStencilAttachment:
    768            return GL_LAYOUT_DEPTH_STENCIL_ATTACHMENT_EXT;
    769        case ImageLayout::DepthStencilReadOnlyAttachment:
    770            return GL_LAYOUT_DEPTH_STENCIL_READ_ONLY_EXT;
    771        case ImageLayout::ShaderReadOnly:
    772            return GL_LAYOUT_SHADER_READ_ONLY_EXT;
    773        case ImageLayout::TransferSrc:
    774            return GL_LAYOUT_TRANSFER_SRC_EXT;
    775        case ImageLayout::TransferDst:
    776            return GL_LAYOUT_TRANSFER_DST_EXT;
    777        case ImageLayout::DepthReadOnlyStencilAttachment:
    778            return GL_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_EXT;
    779        case ImageLayout::DepthAttachmentStencilReadOnly:
    780            return GL_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_EXT;
    781        default:
    782            UNREACHABLE();
    783            return 0;
    784    }
    785 }
    786 
    787 std::ostream &operator<<(std::ostream &os, ImageLayout value)
    788 {
    789    switch (value)
    790    {
    791        case ImageLayout::Undefined:
    792            os << "GL_NONE";
    793            break;
    794        case ImageLayout::General:
    795            os << "GL_LAYOUT_GENERAL_EXT";
    796            break;
    797        case ImageLayout::ColorAttachment:
    798            os << "GL_LAYOUT_COLOR_ATTACHMENT_EXT";
    799            break;
    800        case ImageLayout::DepthStencilAttachment:
    801            os << "GL_LAYOUT_DEPTH_STENCIL_ATTACHMENT_EXT";
    802            break;
    803        case ImageLayout::DepthStencilReadOnlyAttachment:
    804            os << "GL_LAYOUT_DEPTH_STENCIL_READ_ONLY_EXT";
    805            break;
    806        case ImageLayout::ShaderReadOnly:
    807            os << "GL_LAYOUT_SHADER_READ_ONLY_EXT";
    808            break;
    809        case ImageLayout::TransferSrc:
    810            os << "GL_LAYOUT_TRANSFER_SRC_EXT";
    811            break;
    812        case ImageLayout::TransferDst:
    813            os << "GL_LAYOUT_TRANSFER_DST_EXT";
    814            break;
    815        case ImageLayout::DepthReadOnlyStencilAttachment:
    816            os << "GL_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_EXT";
    817            break;
    818        case ImageLayout::DepthAttachmentStencilReadOnly:
    819            os << "GL_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_EXT";
    820            break;
    821        default:
    822            os << "GL_INVALID_ENUM";
    823            break;
    824    }
    825    return os;
    826 }
    827 
    828 template <>
    829 LightParameter FromGLenum<LightParameter>(GLenum from)
    830 {
    831    switch (from)
    832    {
    833        case GL_AMBIENT:
    834            return LightParameter::Ambient;
    835        case GL_AMBIENT_AND_DIFFUSE:
    836            return LightParameter::AmbientAndDiffuse;
    837        case GL_CONSTANT_ATTENUATION:
    838            return LightParameter::ConstantAttenuation;
    839        case GL_DIFFUSE:
    840            return LightParameter::Diffuse;
    841        case GL_LINEAR_ATTENUATION:
    842            return LightParameter::LinearAttenuation;
    843        case GL_POSITION:
    844            return LightParameter::Position;
    845        case GL_QUADRATIC_ATTENUATION:
    846            return LightParameter::QuadraticAttenuation;
    847        case GL_SPECULAR:
    848            return LightParameter::Specular;
    849        case GL_SPOT_CUTOFF:
    850            return LightParameter::SpotCutoff;
    851        case GL_SPOT_DIRECTION:
    852            return LightParameter::SpotDirection;
    853        case GL_SPOT_EXPONENT:
    854            return LightParameter::SpotExponent;
    855        default:
    856            return LightParameter::InvalidEnum;
    857    }
    858 }
    859 
    860 GLenum ToGLenum(LightParameter from)
    861 {
    862    switch (from)
    863    {
    864        case LightParameter::Ambient:
    865            return GL_AMBIENT;
    866        case LightParameter::AmbientAndDiffuse:
    867            return GL_AMBIENT_AND_DIFFUSE;
    868        case LightParameter::ConstantAttenuation:
    869            return GL_CONSTANT_ATTENUATION;
    870        case LightParameter::Diffuse:
    871            return GL_DIFFUSE;
    872        case LightParameter::LinearAttenuation:
    873            return GL_LINEAR_ATTENUATION;
    874        case LightParameter::Position:
    875            return GL_POSITION;
    876        case LightParameter::QuadraticAttenuation:
    877            return GL_QUADRATIC_ATTENUATION;
    878        case LightParameter::Specular:
    879            return GL_SPECULAR;
    880        case LightParameter::SpotCutoff:
    881            return GL_SPOT_CUTOFF;
    882        case LightParameter::SpotDirection:
    883            return GL_SPOT_DIRECTION;
    884        case LightParameter::SpotExponent:
    885            return GL_SPOT_EXPONENT;
    886        default:
    887            UNREACHABLE();
    888            return 0;
    889    }
    890 }
    891 
    892 std::ostream &operator<<(std::ostream &os, LightParameter value)
    893 {
    894    switch (value)
    895    {
    896        case LightParameter::Ambient:
    897            os << "GL_AMBIENT";
    898            break;
    899        case LightParameter::AmbientAndDiffuse:
    900            os << "GL_AMBIENT_AND_DIFFUSE";
    901            break;
    902        case LightParameter::ConstantAttenuation:
    903            os << "GL_CONSTANT_ATTENUATION";
    904            break;
    905        case LightParameter::Diffuse:
    906            os << "GL_DIFFUSE";
    907            break;
    908        case LightParameter::LinearAttenuation:
    909            os << "GL_LINEAR_ATTENUATION";
    910            break;
    911        case LightParameter::Position:
    912            os << "GL_POSITION";
    913            break;
    914        case LightParameter::QuadraticAttenuation:
    915            os << "GL_QUADRATIC_ATTENUATION";
    916            break;
    917        case LightParameter::Specular:
    918            os << "GL_SPECULAR";
    919            break;
    920        case LightParameter::SpotCutoff:
    921            os << "GL_SPOT_CUTOFF";
    922            break;
    923        case LightParameter::SpotDirection:
    924            os << "GL_SPOT_DIRECTION";
    925            break;
    926        case LightParameter::SpotExponent:
    927            os << "GL_SPOT_EXPONENT";
    928            break;
    929        default:
    930            os << "GL_INVALID_ENUM";
    931            break;
    932    }
    933    return os;
    934 }
    935 
    936 template <>
    937 LogicalOperation FromGLenum<LogicalOperation>(GLenum from)
    938 {
    939    switch (from)
    940    {
    941        case GL_AND:
    942            return LogicalOperation::And;
    943        case GL_AND_INVERTED:
    944            return LogicalOperation::AndInverted;
    945        case GL_AND_REVERSE:
    946            return LogicalOperation::AndReverse;
    947        case GL_CLEAR:
    948            return LogicalOperation::Clear;
    949        case GL_COPY:
    950            return LogicalOperation::Copy;
    951        case GL_COPY_INVERTED:
    952            return LogicalOperation::CopyInverted;
    953        case GL_EQUIV:
    954            return LogicalOperation::Equiv;
    955        case GL_INVERT:
    956            return LogicalOperation::Invert;
    957        case GL_NAND:
    958            return LogicalOperation::Nand;
    959        case GL_NOOP:
    960            return LogicalOperation::Noop;
    961        case GL_NOR:
    962            return LogicalOperation::Nor;
    963        case GL_OR:
    964            return LogicalOperation::Or;
    965        case GL_OR_INVERTED:
    966            return LogicalOperation::OrInverted;
    967        case GL_OR_REVERSE:
    968            return LogicalOperation::OrReverse;
    969        case GL_SET:
    970            return LogicalOperation::Set;
    971        case GL_XOR:
    972            return LogicalOperation::Xor;
    973        default:
    974            return LogicalOperation::InvalidEnum;
    975    }
    976 }
    977 
    978 GLenum ToGLenum(LogicalOperation from)
    979 {
    980    switch (from)
    981    {
    982        case LogicalOperation::And:
    983            return GL_AND;
    984        case LogicalOperation::AndInverted:
    985            return GL_AND_INVERTED;
    986        case LogicalOperation::AndReverse:
    987            return GL_AND_REVERSE;
    988        case LogicalOperation::Clear:
    989            return GL_CLEAR;
    990        case LogicalOperation::Copy:
    991            return GL_COPY;
    992        case LogicalOperation::CopyInverted:
    993            return GL_COPY_INVERTED;
    994        case LogicalOperation::Equiv:
    995            return GL_EQUIV;
    996        case LogicalOperation::Invert:
    997            return GL_INVERT;
    998        case LogicalOperation::Nand:
    999            return GL_NAND;
   1000        case LogicalOperation::Noop:
   1001            return GL_NOOP;
   1002        case LogicalOperation::Nor:
   1003            return GL_NOR;
   1004        case LogicalOperation::Or:
   1005            return GL_OR;
   1006        case LogicalOperation::OrInverted:
   1007            return GL_OR_INVERTED;
   1008        case LogicalOperation::OrReverse:
   1009            return GL_OR_REVERSE;
   1010        case LogicalOperation::Set:
   1011            return GL_SET;
   1012        case LogicalOperation::Xor:
   1013            return GL_XOR;
   1014        default:
   1015            UNREACHABLE();
   1016            return 0;
   1017    }
   1018 }
   1019 
   1020 std::ostream &operator<<(std::ostream &os, LogicalOperation value)
   1021 {
   1022    switch (value)
   1023    {
   1024        case LogicalOperation::And:
   1025            os << "GL_AND";
   1026            break;
   1027        case LogicalOperation::AndInverted:
   1028            os << "GL_AND_INVERTED";
   1029            break;
   1030        case LogicalOperation::AndReverse:
   1031            os << "GL_AND_REVERSE";
   1032            break;
   1033        case LogicalOperation::Clear:
   1034            os << "GL_CLEAR";
   1035            break;
   1036        case LogicalOperation::Copy:
   1037            os << "GL_COPY";
   1038            break;
   1039        case LogicalOperation::CopyInverted:
   1040            os << "GL_COPY_INVERTED";
   1041            break;
   1042        case LogicalOperation::Equiv:
   1043            os << "GL_EQUIV";
   1044            break;
   1045        case LogicalOperation::Invert:
   1046            os << "GL_INVERT";
   1047            break;
   1048        case LogicalOperation::Nand:
   1049            os << "GL_NAND";
   1050            break;
   1051        case LogicalOperation::Noop:
   1052            os << "GL_NOOP";
   1053            break;
   1054        case LogicalOperation::Nor:
   1055            os << "GL_NOR";
   1056            break;
   1057        case LogicalOperation::Or:
   1058            os << "GL_OR";
   1059            break;
   1060        case LogicalOperation::OrInverted:
   1061            os << "GL_OR_INVERTED";
   1062            break;
   1063        case LogicalOperation::OrReverse:
   1064            os << "GL_OR_REVERSE";
   1065            break;
   1066        case LogicalOperation::Set:
   1067            os << "GL_SET";
   1068            break;
   1069        case LogicalOperation::Xor:
   1070            os << "GL_XOR";
   1071            break;
   1072        default:
   1073            os << "GL_INVALID_ENUM";
   1074            break;
   1075    }
   1076    return os;
   1077 }
   1078 
   1079 template <>
   1080 MaterialParameter FromGLenum<MaterialParameter>(GLenum from)
   1081 {
   1082    switch (from)
   1083    {
   1084        case GL_AMBIENT:
   1085            return MaterialParameter::Ambient;
   1086        case GL_AMBIENT_AND_DIFFUSE:
   1087            return MaterialParameter::AmbientAndDiffuse;
   1088        case GL_DIFFUSE:
   1089            return MaterialParameter::Diffuse;
   1090        case GL_EMISSION:
   1091            return MaterialParameter::Emission;
   1092        case GL_SHININESS:
   1093            return MaterialParameter::Shininess;
   1094        case GL_SPECULAR:
   1095            return MaterialParameter::Specular;
   1096        default:
   1097            return MaterialParameter::InvalidEnum;
   1098    }
   1099 }
   1100 
   1101 GLenum ToGLenum(MaterialParameter from)
   1102 {
   1103    switch (from)
   1104    {
   1105        case MaterialParameter::Ambient:
   1106            return GL_AMBIENT;
   1107        case MaterialParameter::AmbientAndDiffuse:
   1108            return GL_AMBIENT_AND_DIFFUSE;
   1109        case MaterialParameter::Diffuse:
   1110            return GL_DIFFUSE;
   1111        case MaterialParameter::Emission:
   1112            return GL_EMISSION;
   1113        case MaterialParameter::Shininess:
   1114            return GL_SHININESS;
   1115        case MaterialParameter::Specular:
   1116            return GL_SPECULAR;
   1117        default:
   1118            UNREACHABLE();
   1119            return 0;
   1120    }
   1121 }
   1122 
   1123 std::ostream &operator<<(std::ostream &os, MaterialParameter value)
   1124 {
   1125    switch (value)
   1126    {
   1127        case MaterialParameter::Ambient:
   1128            os << "GL_AMBIENT";
   1129            break;
   1130        case MaterialParameter::AmbientAndDiffuse:
   1131            os << "GL_AMBIENT_AND_DIFFUSE";
   1132            break;
   1133        case MaterialParameter::Diffuse:
   1134            os << "GL_DIFFUSE";
   1135            break;
   1136        case MaterialParameter::Emission:
   1137            os << "GL_EMISSION";
   1138            break;
   1139        case MaterialParameter::Shininess:
   1140            os << "GL_SHININESS";
   1141            break;
   1142        case MaterialParameter::Specular:
   1143            os << "GL_SPECULAR";
   1144            break;
   1145        default:
   1146            os << "GL_INVALID_ENUM";
   1147            break;
   1148    }
   1149    return os;
   1150 }
   1151 
   1152 template <>
   1153 MatrixType FromGLenum<MatrixType>(GLenum from)
   1154 {
   1155    switch (from)
   1156    {
   1157        case GL_MODELVIEW:
   1158            return MatrixType::Modelview;
   1159        case GL_PROJECTION:
   1160            return MatrixType::Projection;
   1161        case GL_TEXTURE:
   1162            return MatrixType::Texture;
   1163        default:
   1164            return MatrixType::InvalidEnum;
   1165    }
   1166 }
   1167 
   1168 GLenum ToGLenum(MatrixType from)
   1169 {
   1170    switch (from)
   1171    {
   1172        case MatrixType::Modelview:
   1173            return GL_MODELVIEW;
   1174        case MatrixType::Projection:
   1175            return GL_PROJECTION;
   1176        case MatrixType::Texture:
   1177            return GL_TEXTURE;
   1178        default:
   1179            UNREACHABLE();
   1180            return 0;
   1181    }
   1182 }
   1183 
   1184 std::ostream &operator<<(std::ostream &os, MatrixType value)
   1185 {
   1186    switch (value)
   1187    {
   1188        case MatrixType::Modelview:
   1189            os << "GL_MODELVIEW";
   1190            break;
   1191        case MatrixType::Projection:
   1192            os << "GL_PROJECTION";
   1193            break;
   1194        case MatrixType::Texture:
   1195            os << "GL_TEXTURE";
   1196            break;
   1197        default:
   1198            os << "GL_INVALID_ENUM";
   1199            break;
   1200    }
   1201    return os;
   1202 }
   1203 
   1204 template <>
   1205 PointParameter FromGLenum<PointParameter>(GLenum from)
   1206 {
   1207    switch (from)
   1208    {
   1209        case GL_POINT_SIZE_MIN:
   1210            return PointParameter::PointSizeMin;
   1211        case GL_POINT_SIZE_MAX:
   1212            return PointParameter::PointSizeMax;
   1213        case GL_POINT_FADE_THRESHOLD_SIZE:
   1214            return PointParameter::PointFadeThresholdSize;
   1215        case GL_POINT_DISTANCE_ATTENUATION:
   1216            return PointParameter::PointDistanceAttenuation;
   1217        default:
   1218            return PointParameter::InvalidEnum;
   1219    }
   1220 }
   1221 
   1222 GLenum ToGLenum(PointParameter from)
   1223 {
   1224    switch (from)
   1225    {
   1226        case PointParameter::PointSizeMin:
   1227            return GL_POINT_SIZE_MIN;
   1228        case PointParameter::PointSizeMax:
   1229            return GL_POINT_SIZE_MAX;
   1230        case PointParameter::PointFadeThresholdSize:
   1231            return GL_POINT_FADE_THRESHOLD_SIZE;
   1232        case PointParameter::PointDistanceAttenuation:
   1233            return GL_POINT_DISTANCE_ATTENUATION;
   1234        default:
   1235            UNREACHABLE();
   1236            return 0;
   1237    }
   1238 }
   1239 
   1240 std::ostream &operator<<(std::ostream &os, PointParameter value)
   1241 {
   1242    switch (value)
   1243    {
   1244        case PointParameter::PointSizeMin:
   1245            os << "GL_POINT_SIZE_MIN";
   1246            break;
   1247        case PointParameter::PointSizeMax:
   1248            os << "GL_POINT_SIZE_MAX";
   1249            break;
   1250        case PointParameter::PointFadeThresholdSize:
   1251            os << "GL_POINT_FADE_THRESHOLD_SIZE";
   1252            break;
   1253        case PointParameter::PointDistanceAttenuation:
   1254            os << "GL_POINT_DISTANCE_ATTENUATION";
   1255            break;
   1256        default:
   1257            os << "GL_INVALID_ENUM";
   1258            break;
   1259    }
   1260    return os;
   1261 }
   1262 
   1263 template <>
   1264 ProvokingVertexConvention FromGLenum<ProvokingVertexConvention>(GLenum from)
   1265 {
   1266    switch (from)
   1267    {
   1268        case GL_FIRST_VERTEX_CONVENTION:
   1269            return ProvokingVertexConvention::FirstVertexConvention;
   1270        case GL_LAST_VERTEX_CONVENTION:
   1271            return ProvokingVertexConvention::LastVertexConvention;
   1272        default:
   1273            return ProvokingVertexConvention::InvalidEnum;
   1274    }
   1275 }
   1276 
   1277 GLenum ToGLenum(ProvokingVertexConvention from)
   1278 {
   1279    switch (from)
   1280    {
   1281        case ProvokingVertexConvention::FirstVertexConvention:
   1282            return GL_FIRST_VERTEX_CONVENTION;
   1283        case ProvokingVertexConvention::LastVertexConvention:
   1284            return GL_LAST_VERTEX_CONVENTION;
   1285        default:
   1286            UNREACHABLE();
   1287            return 0;
   1288    }
   1289 }
   1290 
   1291 std::ostream &operator<<(std::ostream &os, ProvokingVertexConvention value)
   1292 {
   1293    switch (value)
   1294    {
   1295        case ProvokingVertexConvention::FirstVertexConvention:
   1296            os << "GL_FIRST_VERTEX_CONVENTION";
   1297            break;
   1298        case ProvokingVertexConvention::LastVertexConvention:
   1299            os << "GL_LAST_VERTEX_CONVENTION";
   1300            break;
   1301        default:
   1302            os << "GL_INVALID_ENUM";
   1303            break;
   1304    }
   1305    return os;
   1306 }
   1307 
   1308 template <>
   1309 QueryType FromGLenum<QueryType>(GLenum from)
   1310 {
   1311    switch (from)
   1312    {
   1313        case GL_ANY_SAMPLES_PASSED:
   1314            return QueryType::AnySamples;
   1315        case GL_ANY_SAMPLES_PASSED_CONSERVATIVE:
   1316            return QueryType::AnySamplesConservative;
   1317        case GL_COMMANDS_COMPLETED_CHROMIUM:
   1318            return QueryType::CommandsCompleted;
   1319        case GL_PRIMITIVES_GENERATED_EXT:
   1320            return QueryType::PrimitivesGenerated;
   1321        case GL_TIME_ELAPSED_EXT:
   1322            return QueryType::TimeElapsed;
   1323        case GL_TIMESTAMP_EXT:
   1324            return QueryType::Timestamp;
   1325        case GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN:
   1326            return QueryType::TransformFeedbackPrimitivesWritten;
   1327        default:
   1328            return QueryType::InvalidEnum;
   1329    }
   1330 }
   1331 
   1332 GLenum ToGLenum(QueryType from)
   1333 {
   1334    switch (from)
   1335    {
   1336        case QueryType::AnySamples:
   1337            return GL_ANY_SAMPLES_PASSED;
   1338        case QueryType::AnySamplesConservative:
   1339            return GL_ANY_SAMPLES_PASSED_CONSERVATIVE;
   1340        case QueryType::CommandsCompleted:
   1341            return GL_COMMANDS_COMPLETED_CHROMIUM;
   1342        case QueryType::PrimitivesGenerated:
   1343            return GL_PRIMITIVES_GENERATED_EXT;
   1344        case QueryType::TimeElapsed:
   1345            return GL_TIME_ELAPSED_EXT;
   1346        case QueryType::Timestamp:
   1347            return GL_TIMESTAMP_EXT;
   1348        case QueryType::TransformFeedbackPrimitivesWritten:
   1349            return GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN;
   1350        default:
   1351            UNREACHABLE();
   1352            return 0;
   1353    }
   1354 }
   1355 
   1356 std::ostream &operator<<(std::ostream &os, QueryType value)
   1357 {
   1358    switch (value)
   1359    {
   1360        case QueryType::AnySamples:
   1361            os << "GL_ANY_SAMPLES_PASSED";
   1362            break;
   1363        case QueryType::AnySamplesConservative:
   1364            os << "GL_ANY_SAMPLES_PASSED_CONSERVATIVE";
   1365            break;
   1366        case QueryType::CommandsCompleted:
   1367            os << "GL_COMMANDS_COMPLETED_CHROMIUM";
   1368            break;
   1369        case QueryType::PrimitivesGenerated:
   1370            os << "GL_PRIMITIVES_GENERATED_EXT";
   1371            break;
   1372        case QueryType::TimeElapsed:
   1373            os << "GL_TIME_ELAPSED_EXT";
   1374            break;
   1375        case QueryType::Timestamp:
   1376            os << "GL_TIMESTAMP_EXT";
   1377            break;
   1378        case QueryType::TransformFeedbackPrimitivesWritten:
   1379            os << "GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN";
   1380            break;
   1381        default:
   1382            os << "GL_INVALID_ENUM";
   1383            break;
   1384    }
   1385    return os;
   1386 }
   1387 
   1388 template <>
   1389 ShaderType FromGLenum<ShaderType>(GLenum from)
   1390 {
   1391    switch (from)
   1392    {
   1393        case GL_VERTEX_SHADER:
   1394            return ShaderType::Vertex;
   1395        case GL_TESS_CONTROL_SHADER_EXT:
   1396            return ShaderType::TessControl;
   1397        case GL_TESS_EVALUATION_SHADER_EXT:
   1398            return ShaderType::TessEvaluation;
   1399        case GL_GEOMETRY_SHADER_EXT:
   1400            return ShaderType::Geometry;
   1401        case GL_FRAGMENT_SHADER:
   1402            return ShaderType::Fragment;
   1403        case GL_COMPUTE_SHADER:
   1404            return ShaderType::Compute;
   1405        default:
   1406            return ShaderType::InvalidEnum;
   1407    }
   1408 }
   1409 
   1410 GLenum ToGLenum(ShaderType from)
   1411 {
   1412    switch (from)
   1413    {
   1414        case ShaderType::Vertex:
   1415            return GL_VERTEX_SHADER;
   1416        case ShaderType::TessControl:
   1417            return GL_TESS_CONTROL_SHADER_EXT;
   1418        case ShaderType::TessEvaluation:
   1419            return GL_TESS_EVALUATION_SHADER_EXT;
   1420        case ShaderType::Geometry:
   1421            return GL_GEOMETRY_SHADER_EXT;
   1422        case ShaderType::Fragment:
   1423            return GL_FRAGMENT_SHADER;
   1424        case ShaderType::Compute:
   1425            return GL_COMPUTE_SHADER;
   1426        default:
   1427            UNREACHABLE();
   1428            return 0;
   1429    }
   1430 }
   1431 
   1432 std::ostream &operator<<(std::ostream &os, ShaderType value)
   1433 {
   1434    switch (value)
   1435    {
   1436        case ShaderType::Vertex:
   1437            os << "GL_VERTEX_SHADER";
   1438            break;
   1439        case ShaderType::TessControl:
   1440            os << "GL_TESS_CONTROL_SHADER_EXT";
   1441            break;
   1442        case ShaderType::TessEvaluation:
   1443            os << "GL_TESS_EVALUATION_SHADER_EXT";
   1444            break;
   1445        case ShaderType::Geometry:
   1446            os << "GL_GEOMETRY_SHADER_EXT";
   1447            break;
   1448        case ShaderType::Fragment:
   1449            os << "GL_FRAGMENT_SHADER";
   1450            break;
   1451        case ShaderType::Compute:
   1452            os << "GL_COMPUTE_SHADER";
   1453            break;
   1454        default:
   1455            os << "GL_INVALID_ENUM";
   1456            break;
   1457    }
   1458    return os;
   1459 }
   1460 
   1461 template <>
   1462 ShadingModel FromGLenum<ShadingModel>(GLenum from)
   1463 {
   1464    switch (from)
   1465    {
   1466        case GL_FLAT:
   1467            return ShadingModel::Flat;
   1468        case GL_SMOOTH:
   1469            return ShadingModel::Smooth;
   1470        default:
   1471            return ShadingModel::InvalidEnum;
   1472    }
   1473 }
   1474 
   1475 GLenum ToGLenum(ShadingModel from)
   1476 {
   1477    switch (from)
   1478    {
   1479        case ShadingModel::Flat:
   1480            return GL_FLAT;
   1481        case ShadingModel::Smooth:
   1482            return GL_SMOOTH;
   1483        default:
   1484            UNREACHABLE();
   1485            return 0;
   1486    }
   1487 }
   1488 
   1489 std::ostream &operator<<(std::ostream &os, ShadingModel value)
   1490 {
   1491    switch (value)
   1492    {
   1493        case ShadingModel::Flat:
   1494            os << "GL_FLAT";
   1495            break;
   1496        case ShadingModel::Smooth:
   1497            os << "GL_SMOOTH";
   1498            break;
   1499        default:
   1500            os << "GL_INVALID_ENUM";
   1501            break;
   1502    }
   1503    return os;
   1504 }
   1505 
   1506 template <>
   1507 ShadingRate FromGLenum<ShadingRate>(GLenum from)
   1508 {
   1509    switch (from)
   1510    {
   1511        case GL_NONE:
   1512            return ShadingRate::Undefined;
   1513        case GL_SHADING_RATE_1X1_PIXELS_QCOM:
   1514            return ShadingRate::_1x1;
   1515        case GL_SHADING_RATE_1X2_PIXELS_QCOM:
   1516            return ShadingRate::_1x2;
   1517        case GL_SHADING_RATE_2X1_PIXELS_QCOM:
   1518            return ShadingRate::_2x1;
   1519        case GL_SHADING_RATE_2X2_PIXELS_QCOM:
   1520            return ShadingRate::_2x2;
   1521        case GL_SHADING_RATE_4X2_PIXELS_QCOM:
   1522            return ShadingRate::_4x2;
   1523        case GL_SHADING_RATE_4X4_PIXELS_QCOM:
   1524            return ShadingRate::_4x4;
   1525        default:
   1526            return ShadingRate::InvalidEnum;
   1527    }
   1528 }
   1529 
   1530 GLenum ToGLenum(ShadingRate from)
   1531 {
   1532    switch (from)
   1533    {
   1534        case ShadingRate::Undefined:
   1535            return GL_NONE;
   1536        case ShadingRate::_1x1:
   1537            return GL_SHADING_RATE_1X1_PIXELS_QCOM;
   1538        case ShadingRate::_1x2:
   1539            return GL_SHADING_RATE_1X2_PIXELS_QCOM;
   1540        case ShadingRate::_2x1:
   1541            return GL_SHADING_RATE_2X1_PIXELS_QCOM;
   1542        case ShadingRate::_2x2:
   1543            return GL_SHADING_RATE_2X2_PIXELS_QCOM;
   1544        case ShadingRate::_4x2:
   1545            return GL_SHADING_RATE_4X2_PIXELS_QCOM;
   1546        case ShadingRate::_4x4:
   1547            return GL_SHADING_RATE_4X4_PIXELS_QCOM;
   1548        default:
   1549            UNREACHABLE();
   1550            return 0;
   1551    }
   1552 }
   1553 
   1554 std::ostream &operator<<(std::ostream &os, ShadingRate value)
   1555 {
   1556    switch (value)
   1557    {
   1558        case ShadingRate::Undefined:
   1559            os << "GL_NONE";
   1560            break;
   1561        case ShadingRate::_1x1:
   1562            os << "GL_SHADING_RATE_1X1_PIXELS_QCOM";
   1563            break;
   1564        case ShadingRate::_1x2:
   1565            os << "GL_SHADING_RATE_1X2_PIXELS_QCOM";
   1566            break;
   1567        case ShadingRate::_2x1:
   1568            os << "GL_SHADING_RATE_2X1_PIXELS_QCOM";
   1569            break;
   1570        case ShadingRate::_2x2:
   1571            os << "GL_SHADING_RATE_2X2_PIXELS_QCOM";
   1572            break;
   1573        case ShadingRate::_4x2:
   1574            os << "GL_SHADING_RATE_4X2_PIXELS_QCOM";
   1575            break;
   1576        case ShadingRate::_4x4:
   1577            os << "GL_SHADING_RATE_4X4_PIXELS_QCOM";
   1578            break;
   1579        default:
   1580            os << "GL_INVALID_ENUM";
   1581            break;
   1582    }
   1583    return os;
   1584 }
   1585 
   1586 template <>
   1587 TextureCombine FromGLenum<TextureCombine>(GLenum from)
   1588 {
   1589    switch (from)
   1590    {
   1591        case GL_ADD:
   1592            return TextureCombine::Add;
   1593        case GL_ADD_SIGNED:
   1594            return TextureCombine::AddSigned;
   1595        case GL_DOT3_RGB:
   1596            return TextureCombine::Dot3Rgb;
   1597        case GL_DOT3_RGBA:
   1598            return TextureCombine::Dot3Rgba;
   1599        case GL_INTERPOLATE:
   1600            return TextureCombine::Interpolate;
   1601        case GL_MODULATE:
   1602            return TextureCombine::Modulate;
   1603        case GL_REPLACE:
   1604            return TextureCombine::Replace;
   1605        case GL_SUBTRACT:
   1606            return TextureCombine::Subtract;
   1607        default:
   1608            return TextureCombine::InvalidEnum;
   1609    }
   1610 }
   1611 
   1612 GLenum ToGLenum(TextureCombine from)
   1613 {
   1614    switch (from)
   1615    {
   1616        case TextureCombine::Add:
   1617            return GL_ADD;
   1618        case TextureCombine::AddSigned:
   1619            return GL_ADD_SIGNED;
   1620        case TextureCombine::Dot3Rgb:
   1621            return GL_DOT3_RGB;
   1622        case TextureCombine::Dot3Rgba:
   1623            return GL_DOT3_RGBA;
   1624        case TextureCombine::Interpolate:
   1625            return GL_INTERPOLATE;
   1626        case TextureCombine::Modulate:
   1627            return GL_MODULATE;
   1628        case TextureCombine::Replace:
   1629            return GL_REPLACE;
   1630        case TextureCombine::Subtract:
   1631            return GL_SUBTRACT;
   1632        default:
   1633            UNREACHABLE();
   1634            return 0;
   1635    }
   1636 }
   1637 
   1638 std::ostream &operator<<(std::ostream &os, TextureCombine value)
   1639 {
   1640    switch (value)
   1641    {
   1642        case TextureCombine::Add:
   1643            os << "GL_ADD";
   1644            break;
   1645        case TextureCombine::AddSigned:
   1646            os << "GL_ADD_SIGNED";
   1647            break;
   1648        case TextureCombine::Dot3Rgb:
   1649            os << "GL_DOT3_RGB";
   1650            break;
   1651        case TextureCombine::Dot3Rgba:
   1652            os << "GL_DOT3_RGBA";
   1653            break;
   1654        case TextureCombine::Interpolate:
   1655            os << "GL_INTERPOLATE";
   1656            break;
   1657        case TextureCombine::Modulate:
   1658            os << "GL_MODULATE";
   1659            break;
   1660        case TextureCombine::Replace:
   1661            os << "GL_REPLACE";
   1662            break;
   1663        case TextureCombine::Subtract:
   1664            os << "GL_SUBTRACT";
   1665            break;
   1666        default:
   1667            os << "GL_INVALID_ENUM";
   1668            break;
   1669    }
   1670    return os;
   1671 }
   1672 
   1673 template <>
   1674 TextureEnvMode FromGLenum<TextureEnvMode>(GLenum from)
   1675 {
   1676    switch (from)
   1677    {
   1678        case GL_ADD:
   1679            return TextureEnvMode::Add;
   1680        case GL_BLEND:
   1681            return TextureEnvMode::Blend;
   1682        case GL_COMBINE:
   1683            return TextureEnvMode::Combine;
   1684        case GL_DECAL:
   1685            return TextureEnvMode::Decal;
   1686        case GL_MODULATE:
   1687            return TextureEnvMode::Modulate;
   1688        case GL_REPLACE:
   1689            return TextureEnvMode::Replace;
   1690        default:
   1691            return TextureEnvMode::InvalidEnum;
   1692    }
   1693 }
   1694 
   1695 GLenum ToGLenum(TextureEnvMode from)
   1696 {
   1697    switch (from)
   1698    {
   1699        case TextureEnvMode::Add:
   1700            return GL_ADD;
   1701        case TextureEnvMode::Blend:
   1702            return GL_BLEND;
   1703        case TextureEnvMode::Combine:
   1704            return GL_COMBINE;
   1705        case TextureEnvMode::Decal:
   1706            return GL_DECAL;
   1707        case TextureEnvMode::Modulate:
   1708            return GL_MODULATE;
   1709        case TextureEnvMode::Replace:
   1710            return GL_REPLACE;
   1711        default:
   1712            UNREACHABLE();
   1713            return 0;
   1714    }
   1715 }
   1716 
   1717 std::ostream &operator<<(std::ostream &os, TextureEnvMode value)
   1718 {
   1719    switch (value)
   1720    {
   1721        case TextureEnvMode::Add:
   1722            os << "GL_ADD";
   1723            break;
   1724        case TextureEnvMode::Blend:
   1725            os << "GL_BLEND";
   1726            break;
   1727        case TextureEnvMode::Combine:
   1728            os << "GL_COMBINE";
   1729            break;
   1730        case TextureEnvMode::Decal:
   1731            os << "GL_DECAL";
   1732            break;
   1733        case TextureEnvMode::Modulate:
   1734            os << "GL_MODULATE";
   1735            break;
   1736        case TextureEnvMode::Replace:
   1737            os << "GL_REPLACE";
   1738            break;
   1739        default:
   1740            os << "GL_INVALID_ENUM";
   1741            break;
   1742    }
   1743    return os;
   1744 }
   1745 
   1746 template <>
   1747 TextureEnvParameter FromGLenum<TextureEnvParameter>(GLenum from)
   1748 {
   1749    switch (from)
   1750    {
   1751        case GL_TEXTURE_ENV_MODE:
   1752            return TextureEnvParameter::Mode;
   1753        case GL_TEXTURE_ENV_COLOR:
   1754            return TextureEnvParameter::Color;
   1755        case GL_COMBINE_RGB:
   1756            return TextureEnvParameter::CombineRgb;
   1757        case GL_COMBINE_ALPHA:
   1758            return TextureEnvParameter::CombineAlpha;
   1759        case GL_RGB_SCALE:
   1760            return TextureEnvParameter::RgbScale;
   1761        case GL_ALPHA_SCALE:
   1762            return TextureEnvParameter::AlphaScale;
   1763        case GL_SRC0_RGB:
   1764            return TextureEnvParameter::Src0Rgb;
   1765        case GL_SRC1_RGB:
   1766            return TextureEnvParameter::Src1Rgb;
   1767        case GL_SRC2_RGB:
   1768            return TextureEnvParameter::Src2Rgb;
   1769        case GL_SRC0_ALPHA:
   1770            return TextureEnvParameter::Src0Alpha;
   1771        case GL_SRC1_ALPHA:
   1772            return TextureEnvParameter::Src1Alpha;
   1773        case GL_SRC2_ALPHA:
   1774            return TextureEnvParameter::Src2Alpha;
   1775        case GL_OPERAND0_RGB:
   1776            return TextureEnvParameter::Op0Rgb;
   1777        case GL_OPERAND1_RGB:
   1778            return TextureEnvParameter::Op1Rgb;
   1779        case GL_OPERAND2_RGB:
   1780            return TextureEnvParameter::Op2Rgb;
   1781        case GL_OPERAND0_ALPHA:
   1782            return TextureEnvParameter::Op0Alpha;
   1783        case GL_OPERAND1_ALPHA:
   1784            return TextureEnvParameter::Op1Alpha;
   1785        case GL_OPERAND2_ALPHA:
   1786            return TextureEnvParameter::Op2Alpha;
   1787        case GL_COORD_REPLACE_OES:
   1788            return TextureEnvParameter::PointCoordReplace;
   1789        default:
   1790            return TextureEnvParameter::InvalidEnum;
   1791    }
   1792 }
   1793 
   1794 GLenum ToGLenum(TextureEnvParameter from)
   1795 {
   1796    switch (from)
   1797    {
   1798        case TextureEnvParameter::Mode:
   1799            return GL_TEXTURE_ENV_MODE;
   1800        case TextureEnvParameter::Color:
   1801            return GL_TEXTURE_ENV_COLOR;
   1802        case TextureEnvParameter::CombineRgb:
   1803            return GL_COMBINE_RGB;
   1804        case TextureEnvParameter::CombineAlpha:
   1805            return GL_COMBINE_ALPHA;
   1806        case TextureEnvParameter::RgbScale:
   1807            return GL_RGB_SCALE;
   1808        case TextureEnvParameter::AlphaScale:
   1809            return GL_ALPHA_SCALE;
   1810        case TextureEnvParameter::Src0Rgb:
   1811            return GL_SRC0_RGB;
   1812        case TextureEnvParameter::Src1Rgb:
   1813            return GL_SRC1_RGB;
   1814        case TextureEnvParameter::Src2Rgb:
   1815            return GL_SRC2_RGB;
   1816        case TextureEnvParameter::Src0Alpha:
   1817            return GL_SRC0_ALPHA;
   1818        case TextureEnvParameter::Src1Alpha:
   1819            return GL_SRC1_ALPHA;
   1820        case TextureEnvParameter::Src2Alpha:
   1821            return GL_SRC2_ALPHA;
   1822        case TextureEnvParameter::Op0Rgb:
   1823            return GL_OPERAND0_RGB;
   1824        case TextureEnvParameter::Op1Rgb:
   1825            return GL_OPERAND1_RGB;
   1826        case TextureEnvParameter::Op2Rgb:
   1827            return GL_OPERAND2_RGB;
   1828        case TextureEnvParameter::Op0Alpha:
   1829            return GL_OPERAND0_ALPHA;
   1830        case TextureEnvParameter::Op1Alpha:
   1831            return GL_OPERAND1_ALPHA;
   1832        case TextureEnvParameter::Op2Alpha:
   1833            return GL_OPERAND2_ALPHA;
   1834        case TextureEnvParameter::PointCoordReplace:
   1835            return GL_COORD_REPLACE_OES;
   1836        default:
   1837            UNREACHABLE();
   1838            return 0;
   1839    }
   1840 }
   1841 
   1842 std::ostream &operator<<(std::ostream &os, TextureEnvParameter value)
   1843 {
   1844    switch (value)
   1845    {
   1846        case TextureEnvParameter::Mode:
   1847            os << "GL_TEXTURE_ENV_MODE";
   1848            break;
   1849        case TextureEnvParameter::Color:
   1850            os << "GL_TEXTURE_ENV_COLOR";
   1851            break;
   1852        case TextureEnvParameter::CombineRgb:
   1853            os << "GL_COMBINE_RGB";
   1854            break;
   1855        case TextureEnvParameter::CombineAlpha:
   1856            os << "GL_COMBINE_ALPHA";
   1857            break;
   1858        case TextureEnvParameter::RgbScale:
   1859            os << "GL_RGB_SCALE";
   1860            break;
   1861        case TextureEnvParameter::AlphaScale:
   1862            os << "GL_ALPHA_SCALE";
   1863            break;
   1864        case TextureEnvParameter::Src0Rgb:
   1865            os << "GL_SRC0_RGB";
   1866            break;
   1867        case TextureEnvParameter::Src1Rgb:
   1868            os << "GL_SRC1_RGB";
   1869            break;
   1870        case TextureEnvParameter::Src2Rgb:
   1871            os << "GL_SRC2_RGB";
   1872            break;
   1873        case TextureEnvParameter::Src0Alpha:
   1874            os << "GL_SRC0_ALPHA";
   1875            break;
   1876        case TextureEnvParameter::Src1Alpha:
   1877            os << "GL_SRC1_ALPHA";
   1878            break;
   1879        case TextureEnvParameter::Src2Alpha:
   1880            os << "GL_SRC2_ALPHA";
   1881            break;
   1882        case TextureEnvParameter::Op0Rgb:
   1883            os << "GL_OPERAND0_RGB";
   1884            break;
   1885        case TextureEnvParameter::Op1Rgb:
   1886            os << "GL_OPERAND1_RGB";
   1887            break;
   1888        case TextureEnvParameter::Op2Rgb:
   1889            os << "GL_OPERAND2_RGB";
   1890            break;
   1891        case TextureEnvParameter::Op0Alpha:
   1892            os << "GL_OPERAND0_ALPHA";
   1893            break;
   1894        case TextureEnvParameter::Op1Alpha:
   1895            os << "GL_OPERAND1_ALPHA";
   1896            break;
   1897        case TextureEnvParameter::Op2Alpha:
   1898            os << "GL_OPERAND2_ALPHA";
   1899            break;
   1900        case TextureEnvParameter::PointCoordReplace:
   1901            os << "GL_COORD_REPLACE_OES";
   1902            break;
   1903        default:
   1904            os << "GL_INVALID_ENUM";
   1905            break;
   1906    }
   1907    return os;
   1908 }
   1909 
   1910 template <>
   1911 TextureEnvTarget FromGLenum<TextureEnvTarget>(GLenum from)
   1912 {
   1913    switch (from)
   1914    {
   1915        case GL_TEXTURE_ENV:
   1916            return TextureEnvTarget::Env;
   1917        case GL_POINT_SPRITE_OES:
   1918            return TextureEnvTarget::PointSprite;
   1919        default:
   1920            return TextureEnvTarget::InvalidEnum;
   1921    }
   1922 }
   1923 
   1924 GLenum ToGLenum(TextureEnvTarget from)
   1925 {
   1926    switch (from)
   1927    {
   1928        case TextureEnvTarget::Env:
   1929            return GL_TEXTURE_ENV;
   1930        case TextureEnvTarget::PointSprite:
   1931            return GL_POINT_SPRITE_OES;
   1932        default:
   1933            UNREACHABLE();
   1934            return 0;
   1935    }
   1936 }
   1937 
   1938 std::ostream &operator<<(std::ostream &os, TextureEnvTarget value)
   1939 {
   1940    switch (value)
   1941    {
   1942        case TextureEnvTarget::Env:
   1943            os << "GL_TEXTURE_ENV";
   1944            break;
   1945        case TextureEnvTarget::PointSprite:
   1946            os << "GL_POINT_SPRITE_OES";
   1947            break;
   1948        default:
   1949            os << "GL_INVALID_ENUM";
   1950            break;
   1951    }
   1952    return os;
   1953 }
   1954 
   1955 template <>
   1956 TextureOp FromGLenum<TextureOp>(GLenum from)
   1957 {
   1958    switch (from)
   1959    {
   1960        case GL_ONE_MINUS_SRC_ALPHA:
   1961            return TextureOp::OneMinusSrcAlpha;
   1962        case GL_ONE_MINUS_SRC_COLOR:
   1963            return TextureOp::OneMinusSrcColor;
   1964        case GL_SRC_ALPHA:
   1965            return TextureOp::SrcAlpha;
   1966        case GL_SRC_COLOR:
   1967            return TextureOp::SrcColor;
   1968        default:
   1969            return TextureOp::InvalidEnum;
   1970    }
   1971 }
   1972 
   1973 GLenum ToGLenum(TextureOp from)
   1974 {
   1975    switch (from)
   1976    {
   1977        case TextureOp::OneMinusSrcAlpha:
   1978            return GL_ONE_MINUS_SRC_ALPHA;
   1979        case TextureOp::OneMinusSrcColor:
   1980            return GL_ONE_MINUS_SRC_COLOR;
   1981        case TextureOp::SrcAlpha:
   1982            return GL_SRC_ALPHA;
   1983        case TextureOp::SrcColor:
   1984            return GL_SRC_COLOR;
   1985        default:
   1986            UNREACHABLE();
   1987            return 0;
   1988    }
   1989 }
   1990 
   1991 std::ostream &operator<<(std::ostream &os, TextureOp value)
   1992 {
   1993    switch (value)
   1994    {
   1995        case TextureOp::OneMinusSrcAlpha:
   1996            os << "GL_ONE_MINUS_SRC_ALPHA";
   1997            break;
   1998        case TextureOp::OneMinusSrcColor:
   1999            os << "GL_ONE_MINUS_SRC_COLOR";
   2000            break;
   2001        case TextureOp::SrcAlpha:
   2002            os << "GL_SRC_ALPHA";
   2003            break;
   2004        case TextureOp::SrcColor:
   2005            os << "GL_SRC_COLOR";
   2006            break;
   2007        default:
   2008            os << "GL_INVALID_ENUM";
   2009            break;
   2010    }
   2011    return os;
   2012 }
   2013 
   2014 template <>
   2015 TextureSrc FromGLenum<TextureSrc>(GLenum from)
   2016 {
   2017    switch (from)
   2018    {
   2019        case GL_CONSTANT:
   2020            return TextureSrc::Constant;
   2021        case GL_PREVIOUS:
   2022            return TextureSrc::Previous;
   2023        case GL_PRIMARY_COLOR:
   2024            return TextureSrc::PrimaryColor;
   2025        case GL_TEXTURE:
   2026            return TextureSrc::Texture;
   2027        default:
   2028            return TextureSrc::InvalidEnum;
   2029    }
   2030 }
   2031 
   2032 GLenum ToGLenum(TextureSrc from)
   2033 {
   2034    switch (from)
   2035    {
   2036        case TextureSrc::Constant:
   2037            return GL_CONSTANT;
   2038        case TextureSrc::Previous:
   2039            return GL_PREVIOUS;
   2040        case TextureSrc::PrimaryColor:
   2041            return GL_PRIMARY_COLOR;
   2042        case TextureSrc::Texture:
   2043            return GL_TEXTURE;
   2044        default:
   2045            UNREACHABLE();
   2046            return 0;
   2047    }
   2048 }
   2049 
   2050 std::ostream &operator<<(std::ostream &os, TextureSrc value)
   2051 {
   2052    switch (value)
   2053    {
   2054        case TextureSrc::Constant:
   2055            os << "GL_CONSTANT";
   2056            break;
   2057        case TextureSrc::Previous:
   2058            os << "GL_PREVIOUS";
   2059            break;
   2060        case TextureSrc::PrimaryColor:
   2061            os << "GL_PRIMARY_COLOR";
   2062            break;
   2063        case TextureSrc::Texture:
   2064            os << "GL_TEXTURE";
   2065            break;
   2066        default:
   2067            os << "GL_INVALID_ENUM";
   2068            break;
   2069    }
   2070    return os;
   2071 }
   2072 
   2073 template <>
   2074 TextureTarget FromGLenum<TextureTarget>(GLenum from)
   2075 {
   2076    switch (from)
   2077    {
   2078        case GL_TEXTURE_2D:
   2079            return TextureTarget::_2D;
   2080        case GL_TEXTURE_2D_ARRAY:
   2081            return TextureTarget::_2DArray;
   2082        case GL_TEXTURE_2D_MULTISAMPLE:
   2083            return TextureTarget::_2DMultisample;
   2084        case GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES:
   2085            return TextureTarget::_2DMultisampleArray;
   2086        case GL_TEXTURE_3D:
   2087            return TextureTarget::_3D;
   2088        case GL_TEXTURE_EXTERNAL_OES:
   2089            return TextureTarget::External;
   2090        case GL_TEXTURE_RECTANGLE_ANGLE:
   2091            return TextureTarget::Rectangle;
   2092        case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
   2093            return TextureTarget::CubeMapPositiveX;
   2094        case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
   2095            return TextureTarget::CubeMapNegativeX;
   2096        case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
   2097            return TextureTarget::CubeMapPositiveY;
   2098        case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
   2099            return TextureTarget::CubeMapNegativeY;
   2100        case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
   2101            return TextureTarget::CubeMapPositiveZ;
   2102        case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
   2103            return TextureTarget::CubeMapNegativeZ;
   2104        case GL_TEXTURE_CUBE_MAP_ARRAY:
   2105            return TextureTarget::CubeMapArray;
   2106        case GL_TEXTURE_VIDEO_IMAGE_WEBGL:
   2107            return TextureTarget::VideoImage;
   2108        case GL_TEXTURE_BUFFER:
   2109            return TextureTarget::Buffer;
   2110        default:
   2111            return TextureTarget::InvalidEnum;
   2112    }
   2113 }
   2114 
   2115 GLenum ToGLenum(TextureTarget from)
   2116 {
   2117    switch (from)
   2118    {
   2119        case TextureTarget::_2D:
   2120            return GL_TEXTURE_2D;
   2121        case TextureTarget::_2DArray:
   2122            return GL_TEXTURE_2D_ARRAY;
   2123        case TextureTarget::_2DMultisample:
   2124            return GL_TEXTURE_2D_MULTISAMPLE;
   2125        case TextureTarget::_2DMultisampleArray:
   2126            return GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES;
   2127        case TextureTarget::_3D:
   2128            return GL_TEXTURE_3D;
   2129        case TextureTarget::External:
   2130            return GL_TEXTURE_EXTERNAL_OES;
   2131        case TextureTarget::Rectangle:
   2132            return GL_TEXTURE_RECTANGLE_ANGLE;
   2133        case TextureTarget::CubeMapPositiveX:
   2134            return GL_TEXTURE_CUBE_MAP_POSITIVE_X;
   2135        case TextureTarget::CubeMapNegativeX:
   2136            return GL_TEXTURE_CUBE_MAP_NEGATIVE_X;
   2137        case TextureTarget::CubeMapPositiveY:
   2138            return GL_TEXTURE_CUBE_MAP_POSITIVE_Y;
   2139        case TextureTarget::CubeMapNegativeY:
   2140            return GL_TEXTURE_CUBE_MAP_NEGATIVE_Y;
   2141        case TextureTarget::CubeMapPositiveZ:
   2142            return GL_TEXTURE_CUBE_MAP_POSITIVE_Z;
   2143        case TextureTarget::CubeMapNegativeZ:
   2144            return GL_TEXTURE_CUBE_MAP_NEGATIVE_Z;
   2145        case TextureTarget::CubeMapArray:
   2146            return GL_TEXTURE_CUBE_MAP_ARRAY;
   2147        case TextureTarget::VideoImage:
   2148            return GL_TEXTURE_VIDEO_IMAGE_WEBGL;
   2149        case TextureTarget::Buffer:
   2150            return GL_TEXTURE_BUFFER;
   2151        default:
   2152            UNREACHABLE();
   2153            return 0;
   2154    }
   2155 }
   2156 
   2157 std::ostream &operator<<(std::ostream &os, TextureTarget value)
   2158 {
   2159    switch (value)
   2160    {
   2161        case TextureTarget::_2D:
   2162            os << "GL_TEXTURE_2D";
   2163            break;
   2164        case TextureTarget::_2DArray:
   2165            os << "GL_TEXTURE_2D_ARRAY";
   2166            break;
   2167        case TextureTarget::_2DMultisample:
   2168            os << "GL_TEXTURE_2D_MULTISAMPLE";
   2169            break;
   2170        case TextureTarget::_2DMultisampleArray:
   2171            os << "GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES";
   2172            break;
   2173        case TextureTarget::_3D:
   2174            os << "GL_TEXTURE_3D";
   2175            break;
   2176        case TextureTarget::External:
   2177            os << "GL_TEXTURE_EXTERNAL_OES";
   2178            break;
   2179        case TextureTarget::Rectangle:
   2180            os << "GL_TEXTURE_RECTANGLE_ANGLE";
   2181            break;
   2182        case TextureTarget::CubeMapPositiveX:
   2183            os << "GL_TEXTURE_CUBE_MAP_POSITIVE_X";
   2184            break;
   2185        case TextureTarget::CubeMapNegativeX:
   2186            os << "GL_TEXTURE_CUBE_MAP_NEGATIVE_X";
   2187            break;
   2188        case TextureTarget::CubeMapPositiveY:
   2189            os << "GL_TEXTURE_CUBE_MAP_POSITIVE_Y";
   2190            break;
   2191        case TextureTarget::CubeMapNegativeY:
   2192            os << "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y";
   2193            break;
   2194        case TextureTarget::CubeMapPositiveZ:
   2195            os << "GL_TEXTURE_CUBE_MAP_POSITIVE_Z";
   2196            break;
   2197        case TextureTarget::CubeMapNegativeZ:
   2198            os << "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z";
   2199            break;
   2200        case TextureTarget::CubeMapArray:
   2201            os << "GL_TEXTURE_CUBE_MAP_ARRAY";
   2202            break;
   2203        case TextureTarget::VideoImage:
   2204            os << "GL_TEXTURE_VIDEO_IMAGE_WEBGL";
   2205            break;
   2206        case TextureTarget::Buffer:
   2207            os << "GL_TEXTURE_BUFFER";
   2208            break;
   2209        default:
   2210            os << "GL_INVALID_ENUM";
   2211            break;
   2212    }
   2213    return os;
   2214 }
   2215 
   2216 template <>
   2217 TextureType FromGLenum<TextureType>(GLenum from)
   2218 {
   2219    switch (from)
   2220    {
   2221        case GL_TEXTURE_2D:
   2222            return TextureType::_2D;
   2223        case GL_TEXTURE_2D_ARRAY:
   2224            return TextureType::_2DArray;
   2225        case GL_TEXTURE_2D_MULTISAMPLE:
   2226            return TextureType::_2DMultisample;
   2227        case GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES:
   2228            return TextureType::_2DMultisampleArray;
   2229        case GL_TEXTURE_3D:
   2230            return TextureType::_3D;
   2231        case GL_TEXTURE_EXTERNAL_OES:
   2232            return TextureType::External;
   2233        case GL_TEXTURE_RECTANGLE_ANGLE:
   2234            return TextureType::Rectangle;
   2235        case GL_TEXTURE_CUBE_MAP:
   2236            return TextureType::CubeMap;
   2237        case GL_TEXTURE_CUBE_MAP_ARRAY:
   2238            return TextureType::CubeMapArray;
   2239        case GL_TEXTURE_VIDEO_IMAGE_WEBGL:
   2240            return TextureType::VideoImage;
   2241        case GL_TEXTURE_BUFFER:
   2242            return TextureType::Buffer;
   2243        default:
   2244            return TextureType::InvalidEnum;
   2245    }
   2246 }
   2247 
   2248 GLenum ToGLenum(TextureType from)
   2249 {
   2250    switch (from)
   2251    {
   2252        case TextureType::_2D:
   2253            return GL_TEXTURE_2D;
   2254        case TextureType::_2DArray:
   2255            return GL_TEXTURE_2D_ARRAY;
   2256        case TextureType::_2DMultisample:
   2257            return GL_TEXTURE_2D_MULTISAMPLE;
   2258        case TextureType::_2DMultisampleArray:
   2259            return GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES;
   2260        case TextureType::_3D:
   2261            return GL_TEXTURE_3D;
   2262        case TextureType::External:
   2263            return GL_TEXTURE_EXTERNAL_OES;
   2264        case TextureType::Rectangle:
   2265            return GL_TEXTURE_RECTANGLE_ANGLE;
   2266        case TextureType::CubeMap:
   2267            return GL_TEXTURE_CUBE_MAP;
   2268        case TextureType::CubeMapArray:
   2269            return GL_TEXTURE_CUBE_MAP_ARRAY;
   2270        case TextureType::VideoImage:
   2271            return GL_TEXTURE_VIDEO_IMAGE_WEBGL;
   2272        case TextureType::Buffer:
   2273            return GL_TEXTURE_BUFFER;
   2274        default:
   2275            UNREACHABLE();
   2276            return 0;
   2277    }
   2278 }
   2279 
   2280 std::ostream &operator<<(std::ostream &os, TextureType value)
   2281 {
   2282    switch (value)
   2283    {
   2284        case TextureType::_2D:
   2285            os << "GL_TEXTURE_2D";
   2286            break;
   2287        case TextureType::_2DArray:
   2288            os << "GL_TEXTURE_2D_ARRAY";
   2289            break;
   2290        case TextureType::_2DMultisample:
   2291            os << "GL_TEXTURE_2D_MULTISAMPLE";
   2292            break;
   2293        case TextureType::_2DMultisampleArray:
   2294            os << "GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES";
   2295            break;
   2296        case TextureType::_3D:
   2297            os << "GL_TEXTURE_3D";
   2298            break;
   2299        case TextureType::External:
   2300            os << "GL_TEXTURE_EXTERNAL_OES";
   2301            break;
   2302        case TextureType::Rectangle:
   2303            os << "GL_TEXTURE_RECTANGLE_ANGLE";
   2304            break;
   2305        case TextureType::CubeMap:
   2306            os << "GL_TEXTURE_CUBE_MAP";
   2307            break;
   2308        case TextureType::CubeMapArray:
   2309            os << "GL_TEXTURE_CUBE_MAP_ARRAY";
   2310            break;
   2311        case TextureType::VideoImage:
   2312            os << "GL_TEXTURE_VIDEO_IMAGE_WEBGL";
   2313            break;
   2314        case TextureType::Buffer:
   2315            os << "GL_TEXTURE_BUFFER";
   2316            break;
   2317        default:
   2318            os << "GL_INVALID_ENUM";
   2319            break;
   2320    }
   2321    return os;
   2322 }
   2323 
   2324 template <>
   2325 VertexArrayType FromGLenum<VertexArrayType>(GLenum from)
   2326 {
   2327    switch (from)
   2328    {
   2329        case GL_COLOR_ARRAY:
   2330            return VertexArrayType::Color;
   2331        case GL_NORMAL_ARRAY:
   2332            return VertexArrayType::Normal;
   2333        case GL_POINT_SIZE_ARRAY_OES:
   2334            return VertexArrayType::PointSize;
   2335        case GL_TEXTURE_COORD_ARRAY:
   2336            return VertexArrayType::TextureCoord;
   2337        case GL_VERTEX_ARRAY:
   2338            return VertexArrayType::Vertex;
   2339        default:
   2340            return VertexArrayType::InvalidEnum;
   2341    }
   2342 }
   2343 
   2344 GLenum ToGLenum(VertexArrayType from)
   2345 {
   2346    switch (from)
   2347    {
   2348        case VertexArrayType::Color:
   2349            return GL_COLOR_ARRAY;
   2350        case VertexArrayType::Normal:
   2351            return GL_NORMAL_ARRAY;
   2352        case VertexArrayType::PointSize:
   2353            return GL_POINT_SIZE_ARRAY_OES;
   2354        case VertexArrayType::TextureCoord:
   2355            return GL_TEXTURE_COORD_ARRAY;
   2356        case VertexArrayType::Vertex:
   2357            return GL_VERTEX_ARRAY;
   2358        default:
   2359            UNREACHABLE();
   2360            return 0;
   2361    }
   2362 }
   2363 
   2364 std::ostream &operator<<(std::ostream &os, VertexArrayType value)
   2365 {
   2366    switch (value)
   2367    {
   2368        case VertexArrayType::Color:
   2369            os << "GL_COLOR_ARRAY";
   2370            break;
   2371        case VertexArrayType::Normal:
   2372            os << "GL_NORMAL_ARRAY";
   2373            break;
   2374        case VertexArrayType::PointSize:
   2375            os << "GL_POINT_SIZE_ARRAY_OES";
   2376            break;
   2377        case VertexArrayType::TextureCoord:
   2378            os << "GL_TEXTURE_COORD_ARRAY";
   2379            break;
   2380        case VertexArrayType::Vertex:
   2381            os << "GL_VERTEX_ARRAY";
   2382            break;
   2383        default:
   2384            os << "GL_INVALID_ENUM";
   2385            break;
   2386    }
   2387    return os;
   2388 }
   2389 
   2390 template <>
   2391 WrapMode FromGLenum<WrapMode>(GLenum from)
   2392 {
   2393    switch (from)
   2394    {
   2395        case GL_CLAMP_TO_EDGE:
   2396            return WrapMode::ClampToEdge;
   2397        case GL_CLAMP_TO_BORDER:
   2398            return WrapMode::ClampToBorder;
   2399        case GL_MIRRORED_REPEAT:
   2400            return WrapMode::MirroredRepeat;
   2401        case GL_REPEAT:
   2402            return WrapMode::Repeat;
   2403        default:
   2404            return WrapMode::InvalidEnum;
   2405    }
   2406 }
   2407 
   2408 GLenum ToGLenum(WrapMode from)
   2409 {
   2410    switch (from)
   2411    {
   2412        case WrapMode::ClampToEdge:
   2413            return GL_CLAMP_TO_EDGE;
   2414        case WrapMode::ClampToBorder:
   2415            return GL_CLAMP_TO_BORDER;
   2416        case WrapMode::MirroredRepeat:
   2417            return GL_MIRRORED_REPEAT;
   2418        case WrapMode::Repeat:
   2419            return GL_REPEAT;
   2420        default:
   2421            UNREACHABLE();
   2422            return 0;
   2423    }
   2424 }
   2425 
   2426 std::ostream &operator<<(std::ostream &os, WrapMode value)
   2427 {
   2428    switch (value)
   2429    {
   2430        case WrapMode::ClampToEdge:
   2431            os << "GL_CLAMP_TO_EDGE";
   2432            break;
   2433        case WrapMode::ClampToBorder:
   2434            os << "GL_CLAMP_TO_BORDER";
   2435            break;
   2436        case WrapMode::MirroredRepeat:
   2437            os << "GL_MIRRORED_REPEAT";
   2438            break;
   2439        case WrapMode::Repeat:
   2440            os << "GL_REPEAT";
   2441            break;
   2442        default:
   2443            os << "GL_INVALID_ENUM";
   2444            break;
   2445    }
   2446    return os;
   2447 }
   2448 
   2449 }  // namespace gl
	tor-browser The Tor Browser
	git clone https://git.dasho.dev/tor-browser.git
	Log \| Files \| Refs \| README \| LICENSE