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 <>
FromGLenum(GLenum from)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 
ToGLenum(AlphaTestFunc from)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 
operator <<(std::ostream & os,AlphaTestFunc value)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 <>
FromGLenum(GLenum from)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 
ToGLenum(BufferBinding from)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 
operator <<(std::ostream & os,BufferBinding value)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 <>
FromGLenum(GLenum from)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 
ToGLenum(BufferUsage from)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 
operator <<(std::ostream & os,BufferUsage value)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 <>
FromGLenum(GLenum from)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 
ToGLenum(ClientVertexArrayType from)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 
operator <<(std::ostream & os,ClientVertexArrayType value)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 <>
FromGLenum(GLenum from)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 
ToGLenum(CullFaceMode from)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 
operator <<(std::ostream & os,CullFaceMode value)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 <>
FromGLenum(GLenum from)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 
ToGLenum(FilterMode from)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 
operator <<(std::ostream & os,FilterMode value)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 <>
FromGLenum(GLenum from)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 
ToGLenum(FogMode from)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 
operator <<(std::ostream & os,FogMode value)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 <>
FromGLenum(GLenum from)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 
ToGLenum(GraphicsResetStatus from)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 
operator <<(std::ostream & os,GraphicsResetStatus value)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 <>
FromGLenum(GLenum from)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 
ToGLenum(HandleType from)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 
operator <<(std::ostream & os,HandleType value)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 <>
FromGLenum(GLenum from)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 
ToGLenum(HintSetting from)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 
operator <<(std::ostream & os,HintSetting value)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 <>
FromGLenum(GLenum from)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 
ToGLenum(ImageLayout from)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 
operator <<(std::ostream & os,ImageLayout value)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 <>
FromGLenum(GLenum from)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 
ToGLenum(LightParameter from)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 
operator <<(std::ostream & os,LightParameter value)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 <>
FromGLenum(GLenum from)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 
ToGLenum(LogicalOperation from)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 
operator <<(std::ostream & os,LogicalOperation value)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 <>
FromGLenum(GLenum from)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 
ToGLenum(MaterialParameter from)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 
operator <<(std::ostream & os,MaterialParameter value)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 <>
FromGLenum(GLenum from)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 
ToGLenum(MatrixType from)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 
operator <<(std::ostream & os,MatrixType value)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 <>
FromGLenum(GLenum from)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 
ToGLenum(PointParameter from)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 
operator <<(std::ostream & os,PointParameter value)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 <>
FromGLenum(GLenum from)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 
ToGLenum(ProvokingVertexConvention from)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 
operator <<(std::ostream & os,ProvokingVertexConvention value)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 <>
FromGLenum(GLenum from)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 
ToGLenum(QueryType from)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 
operator <<(std::ostream & os,QueryType value)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 <>
FromGLenum(GLenum from)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 
ToGLenum(ShaderType from)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 
operator <<(std::ostream & os,ShaderType value)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 <>
FromGLenum(GLenum from)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 
ToGLenum(ShadingModel from)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 
operator <<(std::ostream & os,ShadingModel value)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 <>
FromGLenum(GLenum from)1507 TextureCombine FromGLenum<TextureCombine>(GLenum from)
1508 {
1509     switch (from)
1510     {
1511         case GL_ADD:
1512             return TextureCombine::Add;
1513         case GL_ADD_SIGNED:
1514             return TextureCombine::AddSigned;
1515         case GL_DOT3_RGB:
1516             return TextureCombine::Dot3Rgb;
1517         case GL_DOT3_RGBA:
1518             return TextureCombine::Dot3Rgba;
1519         case GL_INTERPOLATE:
1520             return TextureCombine::Interpolate;
1521         case GL_MODULATE:
1522             return TextureCombine::Modulate;
1523         case GL_REPLACE:
1524             return TextureCombine::Replace;
1525         case GL_SUBTRACT:
1526             return TextureCombine::Subtract;
1527         default:
1528             return TextureCombine::InvalidEnum;
1529     }
1530 }
1531 
ToGLenum(TextureCombine from)1532 GLenum ToGLenum(TextureCombine from)
1533 {
1534     switch (from)
1535     {
1536         case TextureCombine::Add:
1537             return GL_ADD;
1538         case TextureCombine::AddSigned:
1539             return GL_ADD_SIGNED;
1540         case TextureCombine::Dot3Rgb:
1541             return GL_DOT3_RGB;
1542         case TextureCombine::Dot3Rgba:
1543             return GL_DOT3_RGBA;
1544         case TextureCombine::Interpolate:
1545             return GL_INTERPOLATE;
1546         case TextureCombine::Modulate:
1547             return GL_MODULATE;
1548         case TextureCombine::Replace:
1549             return GL_REPLACE;
1550         case TextureCombine::Subtract:
1551             return GL_SUBTRACT;
1552         default:
1553             UNREACHABLE();
1554             return 0;
1555     }
1556 }
1557 
operator <<(std::ostream & os,TextureCombine value)1558 std::ostream &operator<<(std::ostream &os, TextureCombine value)
1559 {
1560     switch (value)
1561     {
1562         case TextureCombine::Add:
1563             os << "GL_ADD";
1564             break;
1565         case TextureCombine::AddSigned:
1566             os << "GL_ADD_SIGNED";
1567             break;
1568         case TextureCombine::Dot3Rgb:
1569             os << "GL_DOT3_RGB";
1570             break;
1571         case TextureCombine::Dot3Rgba:
1572             os << "GL_DOT3_RGBA";
1573             break;
1574         case TextureCombine::Interpolate:
1575             os << "GL_INTERPOLATE";
1576             break;
1577         case TextureCombine::Modulate:
1578             os << "GL_MODULATE";
1579             break;
1580         case TextureCombine::Replace:
1581             os << "GL_REPLACE";
1582             break;
1583         case TextureCombine::Subtract:
1584             os << "GL_SUBTRACT";
1585             break;
1586         default:
1587             os << "GL_INVALID_ENUM";
1588             break;
1589     }
1590     return os;
1591 }
1592 
1593 template <>
FromGLenum(GLenum from)1594 TextureEnvMode FromGLenum<TextureEnvMode>(GLenum from)
1595 {
1596     switch (from)
1597     {
1598         case GL_ADD:
1599             return TextureEnvMode::Add;
1600         case GL_BLEND:
1601             return TextureEnvMode::Blend;
1602         case GL_COMBINE:
1603             return TextureEnvMode::Combine;
1604         case GL_DECAL:
1605             return TextureEnvMode::Decal;
1606         case GL_MODULATE:
1607             return TextureEnvMode::Modulate;
1608         case GL_REPLACE:
1609             return TextureEnvMode::Replace;
1610         default:
1611             return TextureEnvMode::InvalidEnum;
1612     }
1613 }
1614 
ToGLenum(TextureEnvMode from)1615 GLenum ToGLenum(TextureEnvMode from)
1616 {
1617     switch (from)
1618     {
1619         case TextureEnvMode::Add:
1620             return GL_ADD;
1621         case TextureEnvMode::Blend:
1622             return GL_BLEND;
1623         case TextureEnvMode::Combine:
1624             return GL_COMBINE;
1625         case TextureEnvMode::Decal:
1626             return GL_DECAL;
1627         case TextureEnvMode::Modulate:
1628             return GL_MODULATE;
1629         case TextureEnvMode::Replace:
1630             return GL_REPLACE;
1631         default:
1632             UNREACHABLE();
1633             return 0;
1634     }
1635 }
1636 
operator <<(std::ostream & os,TextureEnvMode value)1637 std::ostream &operator<<(std::ostream &os, TextureEnvMode value)
1638 {
1639     switch (value)
1640     {
1641         case TextureEnvMode::Add:
1642             os << "GL_ADD";
1643             break;
1644         case TextureEnvMode::Blend:
1645             os << "GL_BLEND";
1646             break;
1647         case TextureEnvMode::Combine:
1648             os << "GL_COMBINE";
1649             break;
1650         case TextureEnvMode::Decal:
1651             os << "GL_DECAL";
1652             break;
1653         case TextureEnvMode::Modulate:
1654             os << "GL_MODULATE";
1655             break;
1656         case TextureEnvMode::Replace:
1657             os << "GL_REPLACE";
1658             break;
1659         default:
1660             os << "GL_INVALID_ENUM";
1661             break;
1662     }
1663     return os;
1664 }
1665 
1666 template <>
FromGLenum(GLenum from)1667 TextureEnvParameter FromGLenum<TextureEnvParameter>(GLenum from)
1668 {
1669     switch (from)
1670     {
1671         case GL_TEXTURE_ENV_MODE:
1672             return TextureEnvParameter::Mode;
1673         case GL_TEXTURE_ENV_COLOR:
1674             return TextureEnvParameter::Color;
1675         case GL_COMBINE_RGB:
1676             return TextureEnvParameter::CombineRgb;
1677         case GL_COMBINE_ALPHA:
1678             return TextureEnvParameter::CombineAlpha;
1679         case GL_RGB_SCALE:
1680             return TextureEnvParameter::RgbScale;
1681         case GL_ALPHA_SCALE:
1682             return TextureEnvParameter::AlphaScale;
1683         case GL_SRC0_RGB:
1684             return TextureEnvParameter::Src0Rgb;
1685         case GL_SRC1_RGB:
1686             return TextureEnvParameter::Src1Rgb;
1687         case GL_SRC2_RGB:
1688             return TextureEnvParameter::Src2Rgb;
1689         case GL_SRC0_ALPHA:
1690             return TextureEnvParameter::Src0Alpha;
1691         case GL_SRC1_ALPHA:
1692             return TextureEnvParameter::Src1Alpha;
1693         case GL_SRC2_ALPHA:
1694             return TextureEnvParameter::Src2Alpha;
1695         case GL_OPERAND0_RGB:
1696             return TextureEnvParameter::Op0Rgb;
1697         case GL_OPERAND1_RGB:
1698             return TextureEnvParameter::Op1Rgb;
1699         case GL_OPERAND2_RGB:
1700             return TextureEnvParameter::Op2Rgb;
1701         case GL_OPERAND0_ALPHA:
1702             return TextureEnvParameter::Op0Alpha;
1703         case GL_OPERAND1_ALPHA:
1704             return TextureEnvParameter::Op1Alpha;
1705         case GL_OPERAND2_ALPHA:
1706             return TextureEnvParameter::Op2Alpha;
1707         case GL_COORD_REPLACE_OES:
1708             return TextureEnvParameter::PointCoordReplace;
1709         default:
1710             return TextureEnvParameter::InvalidEnum;
1711     }
1712 }
1713 
ToGLenum(TextureEnvParameter from)1714 GLenum ToGLenum(TextureEnvParameter from)
1715 {
1716     switch (from)
1717     {
1718         case TextureEnvParameter::Mode:
1719             return GL_TEXTURE_ENV_MODE;
1720         case TextureEnvParameter::Color:
1721             return GL_TEXTURE_ENV_COLOR;
1722         case TextureEnvParameter::CombineRgb:
1723             return GL_COMBINE_RGB;
1724         case TextureEnvParameter::CombineAlpha:
1725             return GL_COMBINE_ALPHA;
1726         case TextureEnvParameter::RgbScale:
1727             return GL_RGB_SCALE;
1728         case TextureEnvParameter::AlphaScale:
1729             return GL_ALPHA_SCALE;
1730         case TextureEnvParameter::Src0Rgb:
1731             return GL_SRC0_RGB;
1732         case TextureEnvParameter::Src1Rgb:
1733             return GL_SRC1_RGB;
1734         case TextureEnvParameter::Src2Rgb:
1735             return GL_SRC2_RGB;
1736         case TextureEnvParameter::Src0Alpha:
1737             return GL_SRC0_ALPHA;
1738         case TextureEnvParameter::Src1Alpha:
1739             return GL_SRC1_ALPHA;
1740         case TextureEnvParameter::Src2Alpha:
1741             return GL_SRC2_ALPHA;
1742         case TextureEnvParameter::Op0Rgb:
1743             return GL_OPERAND0_RGB;
1744         case TextureEnvParameter::Op1Rgb:
1745             return GL_OPERAND1_RGB;
1746         case TextureEnvParameter::Op2Rgb:
1747             return GL_OPERAND2_RGB;
1748         case TextureEnvParameter::Op0Alpha:
1749             return GL_OPERAND0_ALPHA;
1750         case TextureEnvParameter::Op1Alpha:
1751             return GL_OPERAND1_ALPHA;
1752         case TextureEnvParameter::Op2Alpha:
1753             return GL_OPERAND2_ALPHA;
1754         case TextureEnvParameter::PointCoordReplace:
1755             return GL_COORD_REPLACE_OES;
1756         default:
1757             UNREACHABLE();
1758             return 0;
1759     }
1760 }
1761 
operator <<(std::ostream & os,TextureEnvParameter value)1762 std::ostream &operator<<(std::ostream &os, TextureEnvParameter value)
1763 {
1764     switch (value)
1765     {
1766         case TextureEnvParameter::Mode:
1767             os << "GL_TEXTURE_ENV_MODE";
1768             break;
1769         case TextureEnvParameter::Color:
1770             os << "GL_TEXTURE_ENV_COLOR";
1771             break;
1772         case TextureEnvParameter::CombineRgb:
1773             os << "GL_COMBINE_RGB";
1774             break;
1775         case TextureEnvParameter::CombineAlpha:
1776             os << "GL_COMBINE_ALPHA";
1777             break;
1778         case TextureEnvParameter::RgbScale:
1779             os << "GL_RGB_SCALE";
1780             break;
1781         case TextureEnvParameter::AlphaScale:
1782             os << "GL_ALPHA_SCALE";
1783             break;
1784         case TextureEnvParameter::Src0Rgb:
1785             os << "GL_SRC0_RGB";
1786             break;
1787         case TextureEnvParameter::Src1Rgb:
1788             os << "GL_SRC1_RGB";
1789             break;
1790         case TextureEnvParameter::Src2Rgb:
1791             os << "GL_SRC2_RGB";
1792             break;
1793         case TextureEnvParameter::Src0Alpha:
1794             os << "GL_SRC0_ALPHA";
1795             break;
1796         case TextureEnvParameter::Src1Alpha:
1797             os << "GL_SRC1_ALPHA";
1798             break;
1799         case TextureEnvParameter::Src2Alpha:
1800             os << "GL_SRC2_ALPHA";
1801             break;
1802         case TextureEnvParameter::Op0Rgb:
1803             os << "GL_OPERAND0_RGB";
1804             break;
1805         case TextureEnvParameter::Op1Rgb:
1806             os << "GL_OPERAND1_RGB";
1807             break;
1808         case TextureEnvParameter::Op2Rgb:
1809             os << "GL_OPERAND2_RGB";
1810             break;
1811         case TextureEnvParameter::Op0Alpha:
1812             os << "GL_OPERAND0_ALPHA";
1813             break;
1814         case TextureEnvParameter::Op1Alpha:
1815             os << "GL_OPERAND1_ALPHA";
1816             break;
1817         case TextureEnvParameter::Op2Alpha:
1818             os << "GL_OPERAND2_ALPHA";
1819             break;
1820         case TextureEnvParameter::PointCoordReplace:
1821             os << "GL_COORD_REPLACE_OES";
1822             break;
1823         default:
1824             os << "GL_INVALID_ENUM";
1825             break;
1826     }
1827     return os;
1828 }
1829 
1830 template <>
FromGLenum(GLenum from)1831 TextureEnvTarget FromGLenum<TextureEnvTarget>(GLenum from)
1832 {
1833     switch (from)
1834     {
1835         case GL_TEXTURE_ENV:
1836             return TextureEnvTarget::Env;
1837         case GL_POINT_SPRITE_OES:
1838             return TextureEnvTarget::PointSprite;
1839         default:
1840             return TextureEnvTarget::InvalidEnum;
1841     }
1842 }
1843 
ToGLenum(TextureEnvTarget from)1844 GLenum ToGLenum(TextureEnvTarget from)
1845 {
1846     switch (from)
1847     {
1848         case TextureEnvTarget::Env:
1849             return GL_TEXTURE_ENV;
1850         case TextureEnvTarget::PointSprite:
1851             return GL_POINT_SPRITE_OES;
1852         default:
1853             UNREACHABLE();
1854             return 0;
1855     }
1856 }
1857 
operator <<(std::ostream & os,TextureEnvTarget value)1858 std::ostream &operator<<(std::ostream &os, TextureEnvTarget value)
1859 {
1860     switch (value)
1861     {
1862         case TextureEnvTarget::Env:
1863             os << "GL_TEXTURE_ENV";
1864             break;
1865         case TextureEnvTarget::PointSprite:
1866             os << "GL_POINT_SPRITE_OES";
1867             break;
1868         default:
1869             os << "GL_INVALID_ENUM";
1870             break;
1871     }
1872     return os;
1873 }
1874 
1875 template <>
FromGLenum(GLenum from)1876 TextureOp FromGLenum<TextureOp>(GLenum from)
1877 {
1878     switch (from)
1879     {
1880         case GL_ONE_MINUS_SRC_ALPHA:
1881             return TextureOp::OneMinusSrcAlpha;
1882         case GL_ONE_MINUS_SRC_COLOR:
1883             return TextureOp::OneMinusSrcColor;
1884         case GL_SRC_ALPHA:
1885             return TextureOp::SrcAlpha;
1886         case GL_SRC_COLOR:
1887             return TextureOp::SrcColor;
1888         default:
1889             return TextureOp::InvalidEnum;
1890     }
1891 }
1892 
ToGLenum(TextureOp from)1893 GLenum ToGLenum(TextureOp from)
1894 {
1895     switch (from)
1896     {
1897         case TextureOp::OneMinusSrcAlpha:
1898             return GL_ONE_MINUS_SRC_ALPHA;
1899         case TextureOp::OneMinusSrcColor:
1900             return GL_ONE_MINUS_SRC_COLOR;
1901         case TextureOp::SrcAlpha:
1902             return GL_SRC_ALPHA;
1903         case TextureOp::SrcColor:
1904             return GL_SRC_COLOR;
1905         default:
1906             UNREACHABLE();
1907             return 0;
1908     }
1909 }
1910 
operator <<(std::ostream & os,TextureOp value)1911 std::ostream &operator<<(std::ostream &os, TextureOp value)
1912 {
1913     switch (value)
1914     {
1915         case TextureOp::OneMinusSrcAlpha:
1916             os << "GL_ONE_MINUS_SRC_ALPHA";
1917             break;
1918         case TextureOp::OneMinusSrcColor:
1919             os << "GL_ONE_MINUS_SRC_COLOR";
1920             break;
1921         case TextureOp::SrcAlpha:
1922             os << "GL_SRC_ALPHA";
1923             break;
1924         case TextureOp::SrcColor:
1925             os << "GL_SRC_COLOR";
1926             break;
1927         default:
1928             os << "GL_INVALID_ENUM";
1929             break;
1930     }
1931     return os;
1932 }
1933 
1934 template <>
FromGLenum(GLenum from)1935 TextureSrc FromGLenum<TextureSrc>(GLenum from)
1936 {
1937     switch (from)
1938     {
1939         case GL_CONSTANT:
1940             return TextureSrc::Constant;
1941         case GL_PREVIOUS:
1942             return TextureSrc::Previous;
1943         case GL_PRIMARY_COLOR:
1944             return TextureSrc::PrimaryColor;
1945         case GL_TEXTURE:
1946             return TextureSrc::Texture;
1947         default:
1948             return TextureSrc::InvalidEnum;
1949     }
1950 }
1951 
ToGLenum(TextureSrc from)1952 GLenum ToGLenum(TextureSrc from)
1953 {
1954     switch (from)
1955     {
1956         case TextureSrc::Constant:
1957             return GL_CONSTANT;
1958         case TextureSrc::Previous:
1959             return GL_PREVIOUS;
1960         case TextureSrc::PrimaryColor:
1961             return GL_PRIMARY_COLOR;
1962         case TextureSrc::Texture:
1963             return GL_TEXTURE;
1964         default:
1965             UNREACHABLE();
1966             return 0;
1967     }
1968 }
1969 
operator <<(std::ostream & os,TextureSrc value)1970 std::ostream &operator<<(std::ostream &os, TextureSrc value)
1971 {
1972     switch (value)
1973     {
1974         case TextureSrc::Constant:
1975             os << "GL_CONSTANT";
1976             break;
1977         case TextureSrc::Previous:
1978             os << "GL_PREVIOUS";
1979             break;
1980         case TextureSrc::PrimaryColor:
1981             os << "GL_PRIMARY_COLOR";
1982             break;
1983         case TextureSrc::Texture:
1984             os << "GL_TEXTURE";
1985             break;
1986         default:
1987             os << "GL_INVALID_ENUM";
1988             break;
1989     }
1990     return os;
1991 }
1992 
1993 template <>
FromGLenum(GLenum from)1994 TextureTarget FromGLenum<TextureTarget>(GLenum from)
1995 {
1996     switch (from)
1997     {
1998         case GL_TEXTURE_2D:
1999             return TextureTarget::_2D;
2000         case GL_TEXTURE_2D_ARRAY:
2001             return TextureTarget::_2DArray;
2002         case GL_TEXTURE_2D_MULTISAMPLE:
2003             return TextureTarget::_2DMultisample;
2004         case GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES:
2005             return TextureTarget::_2DMultisampleArray;
2006         case GL_TEXTURE_3D:
2007             return TextureTarget::_3D;
2008         case GL_TEXTURE_EXTERNAL_OES:
2009             return TextureTarget::External;
2010         case GL_TEXTURE_RECTANGLE_ANGLE:
2011             return TextureTarget::Rectangle;
2012         case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
2013             return TextureTarget::CubeMapPositiveX;
2014         case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
2015             return TextureTarget::CubeMapNegativeX;
2016         case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
2017             return TextureTarget::CubeMapPositiveY;
2018         case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
2019             return TextureTarget::CubeMapNegativeY;
2020         case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
2021             return TextureTarget::CubeMapPositiveZ;
2022         case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
2023             return TextureTarget::CubeMapNegativeZ;
2024         case GL_TEXTURE_CUBE_MAP_ARRAY:
2025             return TextureTarget::CubeMapArray;
2026         case GL_TEXTURE_VIDEO_IMAGE_WEBGL:
2027             return TextureTarget::VideoImage;
2028         case GL_TEXTURE_BUFFER:
2029             return TextureTarget::Buffer;
2030         default:
2031             return TextureTarget::InvalidEnum;
2032     }
2033 }
2034 
ToGLenum(TextureTarget from)2035 GLenum ToGLenum(TextureTarget from)
2036 {
2037     switch (from)
2038     {
2039         case TextureTarget::_2D:
2040             return GL_TEXTURE_2D;
2041         case TextureTarget::_2DArray:
2042             return GL_TEXTURE_2D_ARRAY;
2043         case TextureTarget::_2DMultisample:
2044             return GL_TEXTURE_2D_MULTISAMPLE;
2045         case TextureTarget::_2DMultisampleArray:
2046             return GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES;
2047         case TextureTarget::_3D:
2048             return GL_TEXTURE_3D;
2049         case TextureTarget::External:
2050             return GL_TEXTURE_EXTERNAL_OES;
2051         case TextureTarget::Rectangle:
2052             return GL_TEXTURE_RECTANGLE_ANGLE;
2053         case TextureTarget::CubeMapPositiveX:
2054             return GL_TEXTURE_CUBE_MAP_POSITIVE_X;
2055         case TextureTarget::CubeMapNegativeX:
2056             return GL_TEXTURE_CUBE_MAP_NEGATIVE_X;
2057         case TextureTarget::CubeMapPositiveY:
2058             return GL_TEXTURE_CUBE_MAP_POSITIVE_Y;
2059         case TextureTarget::CubeMapNegativeY:
2060             return GL_TEXTURE_CUBE_MAP_NEGATIVE_Y;
2061         case TextureTarget::CubeMapPositiveZ:
2062             return GL_TEXTURE_CUBE_MAP_POSITIVE_Z;
2063         case TextureTarget::CubeMapNegativeZ:
2064             return GL_TEXTURE_CUBE_MAP_NEGATIVE_Z;
2065         case TextureTarget::CubeMapArray:
2066             return GL_TEXTURE_CUBE_MAP_ARRAY;
2067         case TextureTarget::VideoImage:
2068             return GL_TEXTURE_VIDEO_IMAGE_WEBGL;
2069         case TextureTarget::Buffer:
2070             return GL_TEXTURE_BUFFER;
2071         default:
2072             UNREACHABLE();
2073             return 0;
2074     }
2075 }
2076 
operator <<(std::ostream & os,TextureTarget value)2077 std::ostream &operator<<(std::ostream &os, TextureTarget value)
2078 {
2079     switch (value)
2080     {
2081         case TextureTarget::_2D:
2082             os << "GL_TEXTURE_2D";
2083             break;
2084         case TextureTarget::_2DArray:
2085             os << "GL_TEXTURE_2D_ARRAY";
2086             break;
2087         case TextureTarget::_2DMultisample:
2088             os << "GL_TEXTURE_2D_MULTISAMPLE";
2089             break;
2090         case TextureTarget::_2DMultisampleArray:
2091             os << "GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES";
2092             break;
2093         case TextureTarget::_3D:
2094             os << "GL_TEXTURE_3D";
2095             break;
2096         case TextureTarget::External:
2097             os << "GL_TEXTURE_EXTERNAL_OES";
2098             break;
2099         case TextureTarget::Rectangle:
2100             os << "GL_TEXTURE_RECTANGLE_ANGLE";
2101             break;
2102         case TextureTarget::CubeMapPositiveX:
2103             os << "GL_TEXTURE_CUBE_MAP_POSITIVE_X";
2104             break;
2105         case TextureTarget::CubeMapNegativeX:
2106             os << "GL_TEXTURE_CUBE_MAP_NEGATIVE_X";
2107             break;
2108         case TextureTarget::CubeMapPositiveY:
2109             os << "GL_TEXTURE_CUBE_MAP_POSITIVE_Y";
2110             break;
2111         case TextureTarget::CubeMapNegativeY:
2112             os << "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y";
2113             break;
2114         case TextureTarget::CubeMapPositiveZ:
2115             os << "GL_TEXTURE_CUBE_MAP_POSITIVE_Z";
2116             break;
2117         case TextureTarget::CubeMapNegativeZ:
2118             os << "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z";
2119             break;
2120         case TextureTarget::CubeMapArray:
2121             os << "GL_TEXTURE_CUBE_MAP_ARRAY";
2122             break;
2123         case TextureTarget::VideoImage:
2124             os << "GL_TEXTURE_VIDEO_IMAGE_WEBGL";
2125             break;
2126         case TextureTarget::Buffer:
2127             os << "GL_TEXTURE_BUFFER";
2128             break;
2129         default:
2130             os << "GL_INVALID_ENUM";
2131             break;
2132     }
2133     return os;
2134 }
2135 
2136 template <>
FromGLenum(GLenum from)2137 TextureType FromGLenum<TextureType>(GLenum from)
2138 {
2139     switch (from)
2140     {
2141         case GL_TEXTURE_2D:
2142             return TextureType::_2D;
2143         case GL_TEXTURE_2D_ARRAY:
2144             return TextureType::_2DArray;
2145         case GL_TEXTURE_2D_MULTISAMPLE:
2146             return TextureType::_2DMultisample;
2147         case GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES:
2148             return TextureType::_2DMultisampleArray;
2149         case GL_TEXTURE_3D:
2150             return TextureType::_3D;
2151         case GL_TEXTURE_EXTERNAL_OES:
2152             return TextureType::External;
2153         case GL_TEXTURE_RECTANGLE_ANGLE:
2154             return TextureType::Rectangle;
2155         case GL_TEXTURE_CUBE_MAP:
2156             return TextureType::CubeMap;
2157         case GL_TEXTURE_CUBE_MAP_ARRAY:
2158             return TextureType::CubeMapArray;
2159         case GL_TEXTURE_VIDEO_IMAGE_WEBGL:
2160             return TextureType::VideoImage;
2161         case GL_TEXTURE_BUFFER:
2162             return TextureType::Buffer;
2163         default:
2164             return TextureType::InvalidEnum;
2165     }
2166 }
2167 
ToGLenum(TextureType from)2168 GLenum ToGLenum(TextureType from)
2169 {
2170     switch (from)
2171     {
2172         case TextureType::_2D:
2173             return GL_TEXTURE_2D;
2174         case TextureType::_2DArray:
2175             return GL_TEXTURE_2D_ARRAY;
2176         case TextureType::_2DMultisample:
2177             return GL_TEXTURE_2D_MULTISAMPLE;
2178         case TextureType::_2DMultisampleArray:
2179             return GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES;
2180         case TextureType::_3D:
2181             return GL_TEXTURE_3D;
2182         case TextureType::External:
2183             return GL_TEXTURE_EXTERNAL_OES;
2184         case TextureType::Rectangle:
2185             return GL_TEXTURE_RECTANGLE_ANGLE;
2186         case TextureType::CubeMap:
2187             return GL_TEXTURE_CUBE_MAP;
2188         case TextureType::CubeMapArray:
2189             return GL_TEXTURE_CUBE_MAP_ARRAY;
2190         case TextureType::VideoImage:
2191             return GL_TEXTURE_VIDEO_IMAGE_WEBGL;
2192         case TextureType::Buffer:
2193             return GL_TEXTURE_BUFFER;
2194         default:
2195             UNREACHABLE();
2196             return 0;
2197     }
2198 }
2199 
operator <<(std::ostream & os,TextureType value)2200 std::ostream &operator<<(std::ostream &os, TextureType value)
2201 {
2202     switch (value)
2203     {
2204         case TextureType::_2D:
2205             os << "GL_TEXTURE_2D";
2206             break;
2207         case TextureType::_2DArray:
2208             os << "GL_TEXTURE_2D_ARRAY";
2209             break;
2210         case TextureType::_2DMultisample:
2211             os << "GL_TEXTURE_2D_MULTISAMPLE";
2212             break;
2213         case TextureType::_2DMultisampleArray:
2214             os << "GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES";
2215             break;
2216         case TextureType::_3D:
2217             os << "GL_TEXTURE_3D";
2218             break;
2219         case TextureType::External:
2220             os << "GL_TEXTURE_EXTERNAL_OES";
2221             break;
2222         case TextureType::Rectangle:
2223             os << "GL_TEXTURE_RECTANGLE_ANGLE";
2224             break;
2225         case TextureType::CubeMap:
2226             os << "GL_TEXTURE_CUBE_MAP";
2227             break;
2228         case TextureType::CubeMapArray:
2229             os << "GL_TEXTURE_CUBE_MAP_ARRAY";
2230             break;
2231         case TextureType::VideoImage:
2232             os << "GL_TEXTURE_VIDEO_IMAGE_WEBGL";
2233             break;
2234         case TextureType::Buffer:
2235             os << "GL_TEXTURE_BUFFER";
2236             break;
2237         default:
2238             os << "GL_INVALID_ENUM";
2239             break;
2240     }
2241     return os;
2242 }
2243 
2244 template <>
FromGLenum(GLenum from)2245 VertexArrayType FromGLenum<VertexArrayType>(GLenum from)
2246 {
2247     switch (from)
2248     {
2249         case GL_COLOR_ARRAY:
2250             return VertexArrayType::Color;
2251         case GL_NORMAL_ARRAY:
2252             return VertexArrayType::Normal;
2253         case GL_POINT_SIZE_ARRAY_OES:
2254             return VertexArrayType::PointSize;
2255         case GL_TEXTURE_COORD_ARRAY:
2256             return VertexArrayType::TextureCoord;
2257         case GL_VERTEX_ARRAY:
2258             return VertexArrayType::Vertex;
2259         default:
2260             return VertexArrayType::InvalidEnum;
2261     }
2262 }
2263 
ToGLenum(VertexArrayType from)2264 GLenum ToGLenum(VertexArrayType from)
2265 {
2266     switch (from)
2267     {
2268         case VertexArrayType::Color:
2269             return GL_COLOR_ARRAY;
2270         case VertexArrayType::Normal:
2271             return GL_NORMAL_ARRAY;
2272         case VertexArrayType::PointSize:
2273             return GL_POINT_SIZE_ARRAY_OES;
2274         case VertexArrayType::TextureCoord:
2275             return GL_TEXTURE_COORD_ARRAY;
2276         case VertexArrayType::Vertex:
2277             return GL_VERTEX_ARRAY;
2278         default:
2279             UNREACHABLE();
2280             return 0;
2281     }
2282 }
2283 
operator <<(std::ostream & os,VertexArrayType value)2284 std::ostream &operator<<(std::ostream &os, VertexArrayType value)
2285 {
2286     switch (value)
2287     {
2288         case VertexArrayType::Color:
2289             os << "GL_COLOR_ARRAY";
2290             break;
2291         case VertexArrayType::Normal:
2292             os << "GL_NORMAL_ARRAY";
2293             break;
2294         case VertexArrayType::PointSize:
2295             os << "GL_POINT_SIZE_ARRAY_OES";
2296             break;
2297         case VertexArrayType::TextureCoord:
2298             os << "GL_TEXTURE_COORD_ARRAY";
2299             break;
2300         case VertexArrayType::Vertex:
2301             os << "GL_VERTEX_ARRAY";
2302             break;
2303         default:
2304             os << "GL_INVALID_ENUM";
2305             break;
2306     }
2307     return os;
2308 }
2309 
2310 template <>
FromGLenum(GLenum from)2311 WrapMode FromGLenum<WrapMode>(GLenum from)
2312 {
2313     switch (from)
2314     {
2315         case GL_CLAMP_TO_EDGE:
2316             return WrapMode::ClampToEdge;
2317         case GL_CLAMP_TO_BORDER:
2318             return WrapMode::ClampToBorder;
2319         case GL_MIRRORED_REPEAT:
2320             return WrapMode::MirroredRepeat;
2321         case GL_REPEAT:
2322             return WrapMode::Repeat;
2323         default:
2324             return WrapMode::InvalidEnum;
2325     }
2326 }
2327 
ToGLenum(WrapMode from)2328 GLenum ToGLenum(WrapMode from)
2329 {
2330     switch (from)
2331     {
2332         case WrapMode::ClampToEdge:
2333             return GL_CLAMP_TO_EDGE;
2334         case WrapMode::ClampToBorder:
2335             return GL_CLAMP_TO_BORDER;
2336         case WrapMode::MirroredRepeat:
2337             return GL_MIRRORED_REPEAT;
2338         case WrapMode::Repeat:
2339             return GL_REPEAT;
2340         default:
2341             UNREACHABLE();
2342             return 0;
2343     }
2344 }
2345 
operator <<(std::ostream & os,WrapMode value)2346 std::ostream &operator<<(std::ostream &os, WrapMode value)
2347 {
2348     switch (value)
2349     {
2350         case WrapMode::ClampToEdge:
2351             os << "GL_CLAMP_TO_EDGE";
2352             break;
2353         case WrapMode::ClampToBorder:
2354             os << "GL_CLAMP_TO_BORDER";
2355             break;
2356         case WrapMode::MirroredRepeat:
2357             os << "GL_MIRRORED_REPEAT";
2358             break;
2359         case WrapMode::Repeat:
2360             os << "GL_REPEAT";
2361             break;
2362         default:
2363             os << "GL_INVALID_ENUM";
2364             break;
2365     }
2366     return os;
2367 }
2368 
2369 }  // namespace gl
2370