• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // GENERATED FILE - DO NOT EDIT.
2 // Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml.
3 //
4 // Copyright 2020 The ANGLE Project Authors. All rights reserved.
5 // Use of this source code is governed by a BSD-style license that can be
6 // found in the LICENSE file.
7 //
8 // frame_capture_utils_autogen.h:
9 //   ANGLE Frame capture types and helper functions.
10 
11 #ifndef COMMON_FRAME_CAPTURE_UTILS_AUTOGEN_H_
12 #define COMMON_FRAME_CAPTURE_UTILS_AUTOGEN_H_
13 
14 #include "common/PackedEnums.h"
15 
16 namespace angle
17 {
18 enum class ParamType
19 {
20     TAHardwareBufferConstPointer,
21     TAlphaTestFunc,
22     TBufferBinding,
23     TBufferID,
24     TBufferIDConstPointer,
25     TBufferIDPointer,
26     TBufferUsage,
27     TClientVertexArrayType,
28     TClipDepthMode,
29     TClipOrigin,
30     TCompositorTiming,
31     TContextID,
32     TCullFaceMode,
33     TDrawElementsType,
34     TEGLAttribConstPointer,
35     TEGLAttribKHRPointer,
36     TEGLAttribPointer,
37     TEGLBoolean,
38     TEGLBooleanPointer,
39     TEGLClientBuffer,
40     TEGLConfigPointer,
41     TEGLContext,
42     TEGLDEBUGPROCKHR,
43     TEGLDeviceEXT,
44     TEGLDisplay,
45     TEGLFrameTokenANGLE,
46     TEGLGetBlobFuncANDROID,
47     TEGLImage,
48     TEGLImageKHR,
49     TEGLLabelKHR,
50     TEGLNativeDisplayType,
51     TEGLNativePixmapType,
52     TEGLNativeWindowType,
53     TEGLObjectKHR,
54     TEGLSetBlobFuncANDROID,
55     TEGLStreamKHR,
56     TEGLSurface,
57     TEGLSync,
58     TEGLSyncKHR,
59     TEGLTime,
60     TEGLTimeKHR,
61     TEGLenum,
62     TEGLint,
63     TEGLintConstPointer,
64     TEGLintPointer,
65     TEGLnsecsANDROID,
66     TEGLnsecsANDROIDPointer,
67     TEGLuint64KHR,
68     TEGLuint64KHRPointer,
69     TFenceNVID,
70     TFenceNVIDConstPointer,
71     TFenceNVIDPointer,
72     TFramebufferID,
73     TFramebufferIDConstPointer,
74     TFramebufferIDPointer,
75     TGLDEBUGPROC,
76     TGLDEBUGPROCKHR,
77     TGLbitfield,
78     TGLboolean,
79     TGLbooleanConstPointer,
80     TGLbooleanPointer,
81     TGLbyte,
82     TGLbyteConstPointer,
83     TGLcharConstPointer,
84     TGLcharConstPointerPointer,
85     TGLcharPointer,
86     TGLclampx,
87     TGLdouble,
88     TGLdoubleConstPointer,
89     TGLdoublePointer,
90     TGLeglClientBufferEXT,
91     TGLenum,
92     TGLenumConstPointer,
93     TGLenumPointer,
94     TGLfixed,
95     TGLfixedConstPointer,
96     TGLfixedPointer,
97     TGLfloat,
98     TGLfloatConstPointer,
99     TGLfloatPointer,
100     TGLint,
101     TGLint64,
102     TGLint64Pointer,
103     TGLintConstPointer,
104     TGLintPointer,
105     TGLintptr,
106     TGLintptrConstPointer,
107     TGLshort,
108     TGLshortConstPointer,
109     TGLsizei,
110     TGLsizeiConstPointer,
111     TGLsizeiPointer,
112     TGLsizeiptr,
113     TGLsizeiptrConstPointer,
114     TGLsync,
115     TGLubyte,
116     TGLubyteConstPointer,
117     TGLubytePointer,
118     TGLuint,
119     TGLuint64,
120     TGLuint64ConstPointer,
121     TGLuint64Pointer,
122     TGLuintConstPointer,
123     TGLuintPointer,
124     TGLushort,
125     TGLushortConstPointer,
126     TGLushortPointer,
127     TGraphicsResetStatus,
128     THandleType,
129     TImageID,
130     TLightParameter,
131     TLogicalOperation,
132     TMaterialParameter,
133     TMatrixType,
134     TMemoryObjectID,
135     TMemoryObjectIDConstPointer,
136     TMemoryObjectIDPointer,
137     TObjectType,
138     TPointParameter,
139     TPolygonMode,
140     TPrimitiveMode,
141     TProgramPipelineID,
142     TProgramPipelineIDConstPointer,
143     TProgramPipelineIDPointer,
144     TProvokingVertexConvention,
145     TQueryID,
146     TQueryIDConstPointer,
147     TQueryIDPointer,
148     TQueryType,
149     TRenderbufferID,
150     TRenderbufferIDConstPointer,
151     TRenderbufferIDPointer,
152     TSamplerID,
153     TSamplerIDConstPointer,
154     TSamplerIDPointer,
155     TSemaphoreID,
156     TSemaphoreIDConstPointer,
157     TSemaphoreIDPointer,
158     TShaderProgramID,
159     TShaderProgramIDConstPointer,
160     TShaderProgramIDPointer,
161     TShaderType,
162     TShadingModel,
163     TSurfaceID,
164     TSyncID,
165     TTextureEnvParameter,
166     TTextureEnvTarget,
167     TTextureID,
168     TTextureIDConstPointer,
169     TTextureIDPointer,
170     TTextureTarget,
171     TTextureType,
172     TTimestamp,
173     TTransformFeedbackID,
174     TTransformFeedbackIDConstPointer,
175     TTransformFeedbackIDPointer,
176     TUniformBlockIndex,
177     TUniformLocation,
178     TVertexArrayID,
179     TVertexArrayIDConstPointer,
180     TVertexArrayIDPointer,
181     TVertexAttribType,
182     TcharConstPointer,
183     Tegl_ConfigPointer,
184     Tegl_DevicePointer,
185     Tegl_DisplayPointer,
186     Tegl_StreamPointer,
187     Tegl_SyncID,
188     TvoidConstPointer,
189     TvoidConstPointerPointer,
190     TvoidPointer,
191     TvoidPointerPointer,
192 };
193 
194 constexpr uint32_t kParamTypeCount = 172;
195 
196 union ParamValue
197 {
198     const AHardwareBuffer *AHardwareBufferConstPointerVal;
199     gl::AlphaTestFunc AlphaTestFuncVal;
200     gl::BufferBinding BufferBindingVal;
201     gl::BufferID BufferIDVal;
202     const gl::BufferID *BufferIDConstPointerVal;
203     gl::BufferID *BufferIDPointerVal;
204     gl::BufferUsage BufferUsageVal;
205     gl::ClientVertexArrayType ClientVertexArrayTypeVal;
206     gl::ClipDepthMode ClipDepthModeVal;
207     gl::ClipOrigin ClipOriginVal;
208     egl::CompositorTiming CompositorTimingVal;
209     gl::ContextID ContextIDVal;
210     gl::CullFaceMode CullFaceModeVal;
211     gl::DrawElementsType DrawElementsTypeVal;
212     const EGLAttrib *EGLAttribConstPointerVal;
213     EGLAttribKHR *EGLAttribKHRPointerVal;
214     EGLAttrib *EGLAttribPointerVal;
215     EGLBoolean EGLBooleanVal;
216     EGLBoolean *EGLBooleanPointerVal;
217     EGLClientBuffer EGLClientBufferVal;
218     EGLConfig *EGLConfigPointerVal;
219     EGLContext EGLContextVal;
220     EGLDEBUGPROCKHR EGLDEBUGPROCKHRVal;
221     EGLDeviceEXT EGLDeviceEXTVal;
222     EGLDisplay EGLDisplayVal;
223     EGLFrameTokenANGLE EGLFrameTokenANGLEVal;
224     EGLGetBlobFuncANDROID EGLGetBlobFuncANDROIDVal;
225     EGLImage EGLImageVal;
226     EGLImageKHR EGLImageKHRVal;
227     EGLLabelKHR EGLLabelKHRVal;
228     EGLNativeDisplayType EGLNativeDisplayTypeVal;
229     EGLNativePixmapType EGLNativePixmapTypeVal;
230     EGLNativeWindowType EGLNativeWindowTypeVal;
231     EGLObjectKHR EGLObjectKHRVal;
232     EGLSetBlobFuncANDROID EGLSetBlobFuncANDROIDVal;
233     EGLStreamKHR EGLStreamKHRVal;
234     EGLSurface EGLSurfaceVal;
235     EGLSync EGLSyncVal;
236     EGLSyncKHR EGLSyncKHRVal;
237     EGLTime EGLTimeVal;
238     EGLTimeKHR EGLTimeKHRVal;
239     EGLenum EGLenumVal;
240     EGLint EGLintVal;
241     const EGLint *EGLintConstPointerVal;
242     EGLint *EGLintPointerVal;
243     EGLnsecsANDROID EGLnsecsANDROIDVal;
244     EGLnsecsANDROID *EGLnsecsANDROIDPointerVal;
245     EGLuint64KHR EGLuint64KHRVal;
246     EGLuint64KHR *EGLuint64KHRPointerVal;
247     gl::FenceNVID FenceNVIDVal;
248     const gl::FenceNVID *FenceNVIDConstPointerVal;
249     gl::FenceNVID *FenceNVIDPointerVal;
250     gl::FramebufferID FramebufferIDVal;
251     const gl::FramebufferID *FramebufferIDConstPointerVal;
252     gl::FramebufferID *FramebufferIDPointerVal;
253     GLDEBUGPROC GLDEBUGPROCVal;
254     GLDEBUGPROCKHR GLDEBUGPROCKHRVal;
255     GLbitfield GLbitfieldVal;
256     GLboolean GLbooleanVal;
257     const GLboolean *GLbooleanConstPointerVal;
258     GLboolean *GLbooleanPointerVal;
259     GLbyte GLbyteVal;
260     const GLbyte *GLbyteConstPointerVal;
261     const GLchar *GLcharConstPointerVal;
262     const GLchar *const *GLcharConstPointerPointerVal;
263     GLchar *GLcharPointerVal;
264     GLclampx GLclampxVal;
265     GLdouble GLdoubleVal;
266     const GLdouble *GLdoubleConstPointerVal;
267     GLdouble *GLdoublePointerVal;
268     GLeglClientBufferEXT GLeglClientBufferEXTVal;
269     GLenum GLenumVal;
270     const GLenum *GLenumConstPointerVal;
271     GLenum *GLenumPointerVal;
272     GLfixed GLfixedVal;
273     const GLfixed *GLfixedConstPointerVal;
274     GLfixed *GLfixedPointerVal;
275     GLfloat GLfloatVal;
276     const GLfloat *GLfloatConstPointerVal;
277     GLfloat *GLfloatPointerVal;
278     GLint GLintVal;
279     GLint64 GLint64Val;
280     GLint64 *GLint64PointerVal;
281     const GLint *GLintConstPointerVal;
282     GLint *GLintPointerVal;
283     GLintptr GLintptrVal;
284     const GLintptr *GLintptrConstPointerVal;
285     GLshort GLshortVal;
286     const GLshort *GLshortConstPointerVal;
287     GLsizei GLsizeiVal;
288     const GLsizei *GLsizeiConstPointerVal;
289     GLsizei *GLsizeiPointerVal;
290     GLsizeiptr GLsizeiptrVal;
291     const GLsizeiptr *GLsizeiptrConstPointerVal;
292     GLsync GLsyncVal;
293     GLubyte GLubyteVal;
294     const GLubyte *GLubyteConstPointerVal;
295     GLubyte *GLubytePointerVal;
296     GLuint GLuintVal;
297     GLuint64 GLuint64Val;
298     const GLuint64 *GLuint64ConstPointerVal;
299     GLuint64 *GLuint64PointerVal;
300     const GLuint *GLuintConstPointerVal;
301     GLuint *GLuintPointerVal;
302     GLushort GLushortVal;
303     const GLushort *GLushortConstPointerVal;
304     GLushort *GLushortPointerVal;
305     gl::GraphicsResetStatus GraphicsResetStatusVal;
306     gl::HandleType HandleTypeVal;
307     egl::ImageID ImageIDVal;
308     gl::LightParameter LightParameterVal;
309     gl::LogicalOperation LogicalOperationVal;
310     gl::MaterialParameter MaterialParameterVal;
311     gl::MatrixType MatrixTypeVal;
312     gl::MemoryObjectID MemoryObjectIDVal;
313     const gl::MemoryObjectID *MemoryObjectIDConstPointerVal;
314     gl::MemoryObjectID *MemoryObjectIDPointerVal;
315     egl::ObjectType ObjectTypeVal;
316     gl::PointParameter PointParameterVal;
317     gl::PolygonMode PolygonModeVal;
318     gl::PrimitiveMode PrimitiveModeVal;
319     gl::ProgramPipelineID ProgramPipelineIDVal;
320     const gl::ProgramPipelineID *ProgramPipelineIDConstPointerVal;
321     gl::ProgramPipelineID *ProgramPipelineIDPointerVal;
322     gl::ProvokingVertexConvention ProvokingVertexConventionVal;
323     gl::QueryID QueryIDVal;
324     const gl::QueryID *QueryIDConstPointerVal;
325     gl::QueryID *QueryIDPointerVal;
326     gl::QueryType QueryTypeVal;
327     gl::RenderbufferID RenderbufferIDVal;
328     const gl::RenderbufferID *RenderbufferIDConstPointerVal;
329     gl::RenderbufferID *RenderbufferIDPointerVal;
330     gl::SamplerID SamplerIDVal;
331     const gl::SamplerID *SamplerIDConstPointerVal;
332     gl::SamplerID *SamplerIDPointerVal;
333     gl::SemaphoreID SemaphoreIDVal;
334     const gl::SemaphoreID *SemaphoreIDConstPointerVal;
335     gl::SemaphoreID *SemaphoreIDPointerVal;
336     gl::ShaderProgramID ShaderProgramIDVal;
337     const gl::ShaderProgramID *ShaderProgramIDConstPointerVal;
338     gl::ShaderProgramID *ShaderProgramIDPointerVal;
339     gl::ShaderType ShaderTypeVal;
340     gl::ShadingModel ShadingModelVal;
341     egl::SurfaceID SurfaceIDVal;
342     gl::SyncID SyncIDVal;
343     gl::TextureEnvParameter TextureEnvParameterVal;
344     gl::TextureEnvTarget TextureEnvTargetVal;
345     gl::TextureID TextureIDVal;
346     const gl::TextureID *TextureIDConstPointerVal;
347     gl::TextureID *TextureIDPointerVal;
348     gl::TextureTarget TextureTargetVal;
349     gl::TextureType TextureTypeVal;
350     egl::Timestamp TimestampVal;
351     gl::TransformFeedbackID TransformFeedbackIDVal;
352     const gl::TransformFeedbackID *TransformFeedbackIDConstPointerVal;
353     gl::TransformFeedbackID *TransformFeedbackIDPointerVal;
354     gl::UniformBlockIndex UniformBlockIndexVal;
355     gl::UniformLocation UniformLocationVal;
356     gl::VertexArrayID VertexArrayIDVal;
357     const gl::VertexArrayID *VertexArrayIDConstPointerVal;
358     gl::VertexArrayID *VertexArrayIDPointerVal;
359     gl::VertexAttribType VertexAttribTypeVal;
360     const char *charConstPointerVal;
361     egl::Config *egl_ConfigPointerVal;
362     egl::Device *egl_DevicePointerVal;
363     egl::Display *egl_DisplayPointerVal;
364     egl::Stream *egl_StreamPointerVal;
365     egl::SyncID egl_SyncIDVal;
366     const void *voidConstPointerVal;
367     const void *const *voidConstPointerPointerVal;
368     void *voidPointerVal;
369     void **voidPointerPointerVal;
370 };
371 
372 template <ParamType PType, typename T>
373 T GetParamVal(const ParamValue &value);
374 
375 template <>
376 inline const AHardwareBuffer *GetParamVal<ParamType::TAHardwareBufferConstPointer,
377                                           const AHardwareBuffer *>(const ParamValue &value)
378 {
379     return value.AHardwareBufferConstPointerVal;
380 }
381 
382 template <>
383 inline gl::AlphaTestFunc GetParamVal<ParamType::TAlphaTestFunc, gl::AlphaTestFunc>(
384     const ParamValue &value)
385 {
386     return value.AlphaTestFuncVal;
387 }
388 
389 template <>
390 inline gl::BufferBinding GetParamVal<ParamType::TBufferBinding, gl::BufferBinding>(
391     const ParamValue &value)
392 {
393     return value.BufferBindingVal;
394 }
395 
396 template <>
397 inline gl::BufferID GetParamVal<ParamType::TBufferID, gl::BufferID>(const ParamValue &value)
398 {
399     return value.BufferIDVal;
400 }
401 
402 template <>
403 inline const gl::BufferID *GetParamVal<ParamType::TBufferIDConstPointer, const gl::BufferID *>(
404     const ParamValue &value)
405 {
406     return value.BufferIDConstPointerVal;
407 }
408 
409 template <>
410 inline gl::BufferID *GetParamVal<ParamType::TBufferIDPointer, gl::BufferID *>(
411     const ParamValue &value)
412 {
413     return value.BufferIDPointerVal;
414 }
415 
416 template <>
417 inline gl::BufferUsage GetParamVal<ParamType::TBufferUsage, gl::BufferUsage>(
418     const ParamValue &value)
419 {
420     return value.BufferUsageVal;
421 }
422 
423 template <>
424 inline gl::ClientVertexArrayType
425 GetParamVal<ParamType::TClientVertexArrayType, gl::ClientVertexArrayType>(const ParamValue &value)
426 {
427     return value.ClientVertexArrayTypeVal;
428 }
429 
430 template <>
431 inline gl::ClipDepthMode GetParamVal<ParamType::TClipDepthMode, gl::ClipDepthMode>(
432     const ParamValue &value)
433 {
434     return value.ClipDepthModeVal;
435 }
436 
437 template <>
438 inline gl::ClipOrigin GetParamVal<ParamType::TClipOrigin, gl::ClipOrigin>(const ParamValue &value)
439 {
440     return value.ClipOriginVal;
441 }
442 
443 template <>
444 inline egl::CompositorTiming GetParamVal<ParamType::TCompositorTiming, egl::CompositorTiming>(
445     const ParamValue &value)
446 {
447     return value.CompositorTimingVal;
448 }
449 
450 template <>
451 inline gl::ContextID GetParamVal<ParamType::TContextID, gl::ContextID>(const ParamValue &value)
452 {
453     return value.ContextIDVal;
454 }
455 
456 template <>
457 inline gl::CullFaceMode GetParamVal<ParamType::TCullFaceMode, gl::CullFaceMode>(
458     const ParamValue &value)
459 {
460     return value.CullFaceModeVal;
461 }
462 
463 template <>
464 inline gl::DrawElementsType GetParamVal<ParamType::TDrawElementsType, gl::DrawElementsType>(
465     const ParamValue &value)
466 {
467     return value.DrawElementsTypeVal;
468 }
469 
470 template <>
471 inline const EGLAttrib *GetParamVal<ParamType::TEGLAttribConstPointer, const EGLAttrib *>(
472     const ParamValue &value)
473 {
474     return value.EGLAttribConstPointerVal;
475 }
476 
477 template <>
478 inline EGLAttribKHR *GetParamVal<ParamType::TEGLAttribKHRPointer, EGLAttribKHR *>(
479     const ParamValue &value)
480 {
481     return value.EGLAttribKHRPointerVal;
482 }
483 
484 template <>
485 inline EGLAttrib *GetParamVal<ParamType::TEGLAttribPointer, EGLAttrib *>(const ParamValue &value)
486 {
487     return value.EGLAttribPointerVal;
488 }
489 
490 template <>
491 inline EGLBoolean GetParamVal<ParamType::TEGLBoolean, EGLBoolean>(const ParamValue &value)
492 {
493     return value.EGLBooleanVal;
494 }
495 
496 template <>
497 inline EGLBoolean *GetParamVal<ParamType::TEGLBooleanPointer, EGLBoolean *>(const ParamValue &value)
498 {
499     return value.EGLBooleanPointerVal;
500 }
501 
502 template <>
503 inline EGLClientBuffer GetParamVal<ParamType::TEGLClientBuffer, EGLClientBuffer>(
504     const ParamValue &value)
505 {
506     return value.EGLClientBufferVal;
507 }
508 
509 template <>
510 inline EGLConfig *GetParamVal<ParamType::TEGLConfigPointer, EGLConfig *>(const ParamValue &value)
511 {
512     return value.EGLConfigPointerVal;
513 }
514 
515 template <>
516 inline EGLContext GetParamVal<ParamType::TEGLContext, EGLContext>(const ParamValue &value)
517 {
518     return value.EGLContextVal;
519 }
520 
521 template <>
522 inline EGLDEBUGPROCKHR GetParamVal<ParamType::TEGLDEBUGPROCKHR, EGLDEBUGPROCKHR>(
523     const ParamValue &value)
524 {
525     return value.EGLDEBUGPROCKHRVal;
526 }
527 
528 template <>
529 inline EGLDeviceEXT GetParamVal<ParamType::TEGLDeviceEXT, EGLDeviceEXT>(const ParamValue &value)
530 {
531     return value.EGLDeviceEXTVal;
532 }
533 
534 template <>
535 inline EGLDisplay GetParamVal<ParamType::TEGLDisplay, EGLDisplay>(const ParamValue &value)
536 {
537     return value.EGLDisplayVal;
538 }
539 
540 template <>
541 inline EGLFrameTokenANGLE GetParamVal<ParamType::TEGLFrameTokenANGLE, EGLFrameTokenANGLE>(
542     const ParamValue &value)
543 {
544     return value.EGLFrameTokenANGLEVal;
545 }
546 
547 template <>
548 inline EGLGetBlobFuncANDROID GetParamVal<ParamType::TEGLGetBlobFuncANDROID, EGLGetBlobFuncANDROID>(
549     const ParamValue &value)
550 {
551     return value.EGLGetBlobFuncANDROIDVal;
552 }
553 
554 template <>
555 inline EGLImage GetParamVal<ParamType::TEGLImage, EGLImage>(const ParamValue &value)
556 {
557     return value.EGLImageVal;
558 }
559 
560 template <>
561 inline EGLImageKHR GetParamVal<ParamType::TEGLImageKHR, EGLImageKHR>(const ParamValue &value)
562 {
563     return value.EGLImageKHRVal;
564 }
565 
566 template <>
567 inline EGLLabelKHR GetParamVal<ParamType::TEGLLabelKHR, EGLLabelKHR>(const ParamValue &value)
568 {
569     return value.EGLLabelKHRVal;
570 }
571 
572 template <>
573 inline EGLNativeDisplayType GetParamVal<ParamType::TEGLNativeDisplayType, EGLNativeDisplayType>(
574     const ParamValue &value)
575 {
576     return value.EGLNativeDisplayTypeVal;
577 }
578 
579 template <>
580 inline EGLNativePixmapType GetParamVal<ParamType::TEGLNativePixmapType, EGLNativePixmapType>(
581     const ParamValue &value)
582 {
583     return value.EGLNativePixmapTypeVal;
584 }
585 
586 template <>
587 inline EGLNativeWindowType GetParamVal<ParamType::TEGLNativeWindowType, EGLNativeWindowType>(
588     const ParamValue &value)
589 {
590     return value.EGLNativeWindowTypeVal;
591 }
592 
593 template <>
594 inline EGLObjectKHR GetParamVal<ParamType::TEGLObjectKHR, EGLObjectKHR>(const ParamValue &value)
595 {
596     return value.EGLObjectKHRVal;
597 }
598 
599 template <>
600 inline EGLSetBlobFuncANDROID GetParamVal<ParamType::TEGLSetBlobFuncANDROID, EGLSetBlobFuncANDROID>(
601     const ParamValue &value)
602 {
603     return value.EGLSetBlobFuncANDROIDVal;
604 }
605 
606 template <>
607 inline EGLStreamKHR GetParamVal<ParamType::TEGLStreamKHR, EGLStreamKHR>(const ParamValue &value)
608 {
609     return value.EGLStreamKHRVal;
610 }
611 
612 template <>
613 inline EGLSurface GetParamVal<ParamType::TEGLSurface, EGLSurface>(const ParamValue &value)
614 {
615     return value.EGLSurfaceVal;
616 }
617 
618 template <>
619 inline EGLSync GetParamVal<ParamType::TEGLSync, EGLSync>(const ParamValue &value)
620 {
621     return value.EGLSyncVal;
622 }
623 
624 template <>
625 inline EGLSyncKHR GetParamVal<ParamType::TEGLSyncKHR, EGLSyncKHR>(const ParamValue &value)
626 {
627     return value.EGLSyncKHRVal;
628 }
629 
630 template <>
631 inline EGLTime GetParamVal<ParamType::TEGLTime, EGLTime>(const ParamValue &value)
632 {
633     return value.EGLTimeVal;
634 }
635 
636 template <>
637 inline EGLTimeKHR GetParamVal<ParamType::TEGLTimeKHR, EGLTimeKHR>(const ParamValue &value)
638 {
639     return value.EGLTimeKHRVal;
640 }
641 
642 template <>
643 inline EGLenum GetParamVal<ParamType::TEGLenum, EGLenum>(const ParamValue &value)
644 {
645     return value.EGLenumVal;
646 }
647 
648 template <>
649 inline EGLint GetParamVal<ParamType::TEGLint, EGLint>(const ParamValue &value)
650 {
651     return value.EGLintVal;
652 }
653 
654 template <>
655 inline const EGLint *GetParamVal<ParamType::TEGLintConstPointer, const EGLint *>(
656     const ParamValue &value)
657 {
658     return value.EGLintConstPointerVal;
659 }
660 
661 template <>
662 inline EGLint *GetParamVal<ParamType::TEGLintPointer, EGLint *>(const ParamValue &value)
663 {
664     return value.EGLintPointerVal;
665 }
666 
667 template <>
668 inline EGLnsecsANDROID GetParamVal<ParamType::TEGLnsecsANDROID, EGLnsecsANDROID>(
669     const ParamValue &value)
670 {
671     return value.EGLnsecsANDROIDVal;
672 }
673 
674 template <>
675 inline EGLnsecsANDROID *GetParamVal<ParamType::TEGLnsecsANDROIDPointer, EGLnsecsANDROID *>(
676     const ParamValue &value)
677 {
678     return value.EGLnsecsANDROIDPointerVal;
679 }
680 
681 template <>
682 inline EGLuint64KHR GetParamVal<ParamType::TEGLuint64KHR, EGLuint64KHR>(const ParamValue &value)
683 {
684     return value.EGLuint64KHRVal;
685 }
686 
687 template <>
688 inline EGLuint64KHR *GetParamVal<ParamType::TEGLuint64KHRPointer, EGLuint64KHR *>(
689     const ParamValue &value)
690 {
691     return value.EGLuint64KHRPointerVal;
692 }
693 
694 template <>
695 inline gl::FenceNVID GetParamVal<ParamType::TFenceNVID, gl::FenceNVID>(const ParamValue &value)
696 {
697     return value.FenceNVIDVal;
698 }
699 
700 template <>
701 inline const gl::FenceNVID *GetParamVal<ParamType::TFenceNVIDConstPointer, const gl::FenceNVID *>(
702     const ParamValue &value)
703 {
704     return value.FenceNVIDConstPointerVal;
705 }
706 
707 template <>
708 inline gl::FenceNVID *GetParamVal<ParamType::TFenceNVIDPointer, gl::FenceNVID *>(
709     const ParamValue &value)
710 {
711     return value.FenceNVIDPointerVal;
712 }
713 
714 template <>
715 inline gl::FramebufferID GetParamVal<ParamType::TFramebufferID, gl::FramebufferID>(
716     const ParamValue &value)
717 {
718     return value.FramebufferIDVal;
719 }
720 
721 template <>
722 inline const gl::FramebufferID *GetParamVal<ParamType::TFramebufferIDConstPointer,
723                                             const gl::FramebufferID *>(const ParamValue &value)
724 {
725     return value.FramebufferIDConstPointerVal;
726 }
727 
728 template <>
729 inline gl::FramebufferID *GetParamVal<ParamType::TFramebufferIDPointer, gl::FramebufferID *>(
730     const ParamValue &value)
731 {
732     return value.FramebufferIDPointerVal;
733 }
734 
735 template <>
736 inline GLDEBUGPROC GetParamVal<ParamType::TGLDEBUGPROC, GLDEBUGPROC>(const ParamValue &value)
737 {
738     return value.GLDEBUGPROCVal;
739 }
740 
741 template <>
742 inline GLDEBUGPROCKHR GetParamVal<ParamType::TGLDEBUGPROCKHR, GLDEBUGPROCKHR>(
743     const ParamValue &value)
744 {
745     return value.GLDEBUGPROCKHRVal;
746 }
747 
748 template <>
749 inline GLbitfield GetParamVal<ParamType::TGLbitfield, GLbitfield>(const ParamValue &value)
750 {
751     return value.GLbitfieldVal;
752 }
753 
754 template <>
755 inline GLboolean GetParamVal<ParamType::TGLboolean, GLboolean>(const ParamValue &value)
756 {
757     return value.GLbooleanVal;
758 }
759 
760 template <>
761 inline const GLboolean *GetParamVal<ParamType::TGLbooleanConstPointer, const GLboolean *>(
762     const ParamValue &value)
763 {
764     return value.GLbooleanConstPointerVal;
765 }
766 
767 template <>
768 inline GLboolean *GetParamVal<ParamType::TGLbooleanPointer, GLboolean *>(const ParamValue &value)
769 {
770     return value.GLbooleanPointerVal;
771 }
772 
773 template <>
774 inline GLbyte GetParamVal<ParamType::TGLbyte, GLbyte>(const ParamValue &value)
775 {
776     return value.GLbyteVal;
777 }
778 
779 template <>
780 inline const GLbyte *GetParamVal<ParamType::TGLbyteConstPointer, const GLbyte *>(
781     const ParamValue &value)
782 {
783     return value.GLbyteConstPointerVal;
784 }
785 
786 template <>
787 inline const GLchar *GetParamVal<ParamType::TGLcharConstPointer, const GLchar *>(
788     const ParamValue &value)
789 {
790     return value.GLcharConstPointerVal;
791 }
792 
793 template <>
794 inline const GLchar *const *
795 GetParamVal<ParamType::TGLcharConstPointerPointer, const GLchar *const *>(const ParamValue &value)
796 {
797     return value.GLcharConstPointerPointerVal;
798 }
799 
800 template <>
801 inline GLchar *GetParamVal<ParamType::TGLcharPointer, GLchar *>(const ParamValue &value)
802 {
803     return value.GLcharPointerVal;
804 }
805 
806 template <>
807 inline GLclampx GetParamVal<ParamType::TGLclampx, GLclampx>(const ParamValue &value)
808 {
809     return value.GLclampxVal;
810 }
811 
812 template <>
813 inline GLdouble GetParamVal<ParamType::TGLdouble, GLdouble>(const ParamValue &value)
814 {
815     return value.GLdoubleVal;
816 }
817 
818 template <>
819 inline const GLdouble *GetParamVal<ParamType::TGLdoubleConstPointer, const GLdouble *>(
820     const ParamValue &value)
821 {
822     return value.GLdoubleConstPointerVal;
823 }
824 
825 template <>
826 inline GLdouble *GetParamVal<ParamType::TGLdoublePointer, GLdouble *>(const ParamValue &value)
827 {
828     return value.GLdoublePointerVal;
829 }
830 
831 template <>
832 inline GLeglClientBufferEXT GetParamVal<ParamType::TGLeglClientBufferEXT, GLeglClientBufferEXT>(
833     const ParamValue &value)
834 {
835     return value.GLeglClientBufferEXTVal;
836 }
837 
838 template <>
839 inline GLenum GetParamVal<ParamType::TGLenum, GLenum>(const ParamValue &value)
840 {
841     return value.GLenumVal;
842 }
843 
844 template <>
845 inline const GLenum *GetParamVal<ParamType::TGLenumConstPointer, const GLenum *>(
846     const ParamValue &value)
847 {
848     return value.GLenumConstPointerVal;
849 }
850 
851 template <>
852 inline GLenum *GetParamVal<ParamType::TGLenumPointer, GLenum *>(const ParamValue &value)
853 {
854     return value.GLenumPointerVal;
855 }
856 
857 template <>
858 inline GLfixed GetParamVal<ParamType::TGLfixed, GLfixed>(const ParamValue &value)
859 {
860     return value.GLfixedVal;
861 }
862 
863 template <>
864 inline const GLfixed *GetParamVal<ParamType::TGLfixedConstPointer, const GLfixed *>(
865     const ParamValue &value)
866 {
867     return value.GLfixedConstPointerVal;
868 }
869 
870 template <>
871 inline GLfixed *GetParamVal<ParamType::TGLfixedPointer, GLfixed *>(const ParamValue &value)
872 {
873     return value.GLfixedPointerVal;
874 }
875 
876 template <>
877 inline GLfloat GetParamVal<ParamType::TGLfloat, GLfloat>(const ParamValue &value)
878 {
879     return value.GLfloatVal;
880 }
881 
882 template <>
883 inline const GLfloat *GetParamVal<ParamType::TGLfloatConstPointer, const GLfloat *>(
884     const ParamValue &value)
885 {
886     return value.GLfloatConstPointerVal;
887 }
888 
889 template <>
890 inline GLfloat *GetParamVal<ParamType::TGLfloatPointer, GLfloat *>(const ParamValue &value)
891 {
892     return value.GLfloatPointerVal;
893 }
894 
895 template <>
896 inline GLint GetParamVal<ParamType::TGLint, GLint>(const ParamValue &value)
897 {
898     return value.GLintVal;
899 }
900 
901 template <>
902 inline GLint64 GetParamVal<ParamType::TGLint64, GLint64>(const ParamValue &value)
903 {
904     return value.GLint64Val;
905 }
906 
907 template <>
908 inline GLint64 *GetParamVal<ParamType::TGLint64Pointer, GLint64 *>(const ParamValue &value)
909 {
910     return value.GLint64PointerVal;
911 }
912 
913 template <>
914 inline const GLint *GetParamVal<ParamType::TGLintConstPointer, const GLint *>(
915     const ParamValue &value)
916 {
917     return value.GLintConstPointerVal;
918 }
919 
920 template <>
921 inline GLint *GetParamVal<ParamType::TGLintPointer, GLint *>(const ParamValue &value)
922 {
923     return value.GLintPointerVal;
924 }
925 
926 template <>
927 inline GLintptr GetParamVal<ParamType::TGLintptr, GLintptr>(const ParamValue &value)
928 {
929     return value.GLintptrVal;
930 }
931 
932 template <>
933 inline const GLintptr *GetParamVal<ParamType::TGLintptrConstPointer, const GLintptr *>(
934     const ParamValue &value)
935 {
936     return value.GLintptrConstPointerVal;
937 }
938 
939 template <>
940 inline GLshort GetParamVal<ParamType::TGLshort, GLshort>(const ParamValue &value)
941 {
942     return value.GLshortVal;
943 }
944 
945 template <>
946 inline const GLshort *GetParamVal<ParamType::TGLshortConstPointer, const GLshort *>(
947     const ParamValue &value)
948 {
949     return value.GLshortConstPointerVal;
950 }
951 
952 template <>
953 inline GLsizei GetParamVal<ParamType::TGLsizei, GLsizei>(const ParamValue &value)
954 {
955     return value.GLsizeiVal;
956 }
957 
958 template <>
959 inline const GLsizei *GetParamVal<ParamType::TGLsizeiConstPointer, const GLsizei *>(
960     const ParamValue &value)
961 {
962     return value.GLsizeiConstPointerVal;
963 }
964 
965 template <>
966 inline GLsizei *GetParamVal<ParamType::TGLsizeiPointer, GLsizei *>(const ParamValue &value)
967 {
968     return value.GLsizeiPointerVal;
969 }
970 
971 template <>
972 inline GLsizeiptr GetParamVal<ParamType::TGLsizeiptr, GLsizeiptr>(const ParamValue &value)
973 {
974     return value.GLsizeiptrVal;
975 }
976 
977 template <>
978 inline const GLsizeiptr *GetParamVal<ParamType::TGLsizeiptrConstPointer, const GLsizeiptr *>(
979     const ParamValue &value)
980 {
981     return value.GLsizeiptrConstPointerVal;
982 }
983 
984 template <>
985 inline GLsync GetParamVal<ParamType::TGLsync, GLsync>(const ParamValue &value)
986 {
987     return value.GLsyncVal;
988 }
989 
990 template <>
991 inline GLubyte GetParamVal<ParamType::TGLubyte, GLubyte>(const ParamValue &value)
992 {
993     return value.GLubyteVal;
994 }
995 
996 template <>
997 inline const GLubyte *GetParamVal<ParamType::TGLubyteConstPointer, const GLubyte *>(
998     const ParamValue &value)
999 {
1000     return value.GLubyteConstPointerVal;
1001 }
1002 
1003 template <>
1004 inline GLubyte *GetParamVal<ParamType::TGLubytePointer, GLubyte *>(const ParamValue &value)
1005 {
1006     return value.GLubytePointerVal;
1007 }
1008 
1009 template <>
1010 inline GLuint GetParamVal<ParamType::TGLuint, GLuint>(const ParamValue &value)
1011 {
1012     return value.GLuintVal;
1013 }
1014 
1015 template <>
1016 inline GLuint64 GetParamVal<ParamType::TGLuint64, GLuint64>(const ParamValue &value)
1017 {
1018     return value.GLuint64Val;
1019 }
1020 
1021 template <>
1022 inline const GLuint64 *GetParamVal<ParamType::TGLuint64ConstPointer, const GLuint64 *>(
1023     const ParamValue &value)
1024 {
1025     return value.GLuint64ConstPointerVal;
1026 }
1027 
1028 template <>
1029 inline GLuint64 *GetParamVal<ParamType::TGLuint64Pointer, GLuint64 *>(const ParamValue &value)
1030 {
1031     return value.GLuint64PointerVal;
1032 }
1033 
1034 template <>
1035 inline const GLuint *GetParamVal<ParamType::TGLuintConstPointer, const GLuint *>(
1036     const ParamValue &value)
1037 {
1038     return value.GLuintConstPointerVal;
1039 }
1040 
1041 template <>
1042 inline GLuint *GetParamVal<ParamType::TGLuintPointer, GLuint *>(const ParamValue &value)
1043 {
1044     return value.GLuintPointerVal;
1045 }
1046 
1047 template <>
1048 inline GLushort GetParamVal<ParamType::TGLushort, GLushort>(const ParamValue &value)
1049 {
1050     return value.GLushortVal;
1051 }
1052 
1053 template <>
1054 inline const GLushort *GetParamVal<ParamType::TGLushortConstPointer, const GLushort *>(
1055     const ParamValue &value)
1056 {
1057     return value.GLushortConstPointerVal;
1058 }
1059 
1060 template <>
1061 inline GLushort *GetParamVal<ParamType::TGLushortPointer, GLushort *>(const ParamValue &value)
1062 {
1063     return value.GLushortPointerVal;
1064 }
1065 
1066 template <>
1067 inline gl::GraphicsResetStatus
1068 GetParamVal<ParamType::TGraphicsResetStatus, gl::GraphicsResetStatus>(const ParamValue &value)
1069 {
1070     return value.GraphicsResetStatusVal;
1071 }
1072 
1073 template <>
1074 inline gl::HandleType GetParamVal<ParamType::THandleType, gl::HandleType>(const ParamValue &value)
1075 {
1076     return value.HandleTypeVal;
1077 }
1078 
1079 template <>
1080 inline egl::ImageID GetParamVal<ParamType::TImageID, egl::ImageID>(const ParamValue &value)
1081 {
1082     return value.ImageIDVal;
1083 }
1084 
1085 template <>
1086 inline gl::LightParameter GetParamVal<ParamType::TLightParameter, gl::LightParameter>(
1087     const ParamValue &value)
1088 {
1089     return value.LightParameterVal;
1090 }
1091 
1092 template <>
1093 inline gl::LogicalOperation GetParamVal<ParamType::TLogicalOperation, gl::LogicalOperation>(
1094     const ParamValue &value)
1095 {
1096     return value.LogicalOperationVal;
1097 }
1098 
1099 template <>
1100 inline gl::MaterialParameter GetParamVal<ParamType::TMaterialParameter, gl::MaterialParameter>(
1101     const ParamValue &value)
1102 {
1103     return value.MaterialParameterVal;
1104 }
1105 
1106 template <>
1107 inline gl::MatrixType GetParamVal<ParamType::TMatrixType, gl::MatrixType>(const ParamValue &value)
1108 {
1109     return value.MatrixTypeVal;
1110 }
1111 
1112 template <>
1113 inline gl::MemoryObjectID GetParamVal<ParamType::TMemoryObjectID, gl::MemoryObjectID>(
1114     const ParamValue &value)
1115 {
1116     return value.MemoryObjectIDVal;
1117 }
1118 
1119 template <>
1120 inline const gl::MemoryObjectID *GetParamVal<ParamType::TMemoryObjectIDConstPointer,
1121                                              const gl::MemoryObjectID *>(const ParamValue &value)
1122 {
1123     return value.MemoryObjectIDConstPointerVal;
1124 }
1125 
1126 template <>
1127 inline gl::MemoryObjectID *GetParamVal<ParamType::TMemoryObjectIDPointer, gl::MemoryObjectID *>(
1128     const ParamValue &value)
1129 {
1130     return value.MemoryObjectIDPointerVal;
1131 }
1132 
1133 template <>
1134 inline egl::ObjectType GetParamVal<ParamType::TObjectType, egl::ObjectType>(const ParamValue &value)
1135 {
1136     return value.ObjectTypeVal;
1137 }
1138 
1139 template <>
1140 inline gl::PointParameter GetParamVal<ParamType::TPointParameter, gl::PointParameter>(
1141     const ParamValue &value)
1142 {
1143     return value.PointParameterVal;
1144 }
1145 
1146 template <>
1147 inline gl::PolygonMode GetParamVal<ParamType::TPolygonMode, gl::PolygonMode>(
1148     const ParamValue &value)
1149 {
1150     return value.PolygonModeVal;
1151 }
1152 
1153 template <>
1154 inline gl::PrimitiveMode GetParamVal<ParamType::TPrimitiveMode, gl::PrimitiveMode>(
1155     const ParamValue &value)
1156 {
1157     return value.PrimitiveModeVal;
1158 }
1159 
1160 template <>
1161 inline gl::ProgramPipelineID GetParamVal<ParamType::TProgramPipelineID, gl::ProgramPipelineID>(
1162     const ParamValue &value)
1163 {
1164     return value.ProgramPipelineIDVal;
1165 }
1166 
1167 template <>
1168 inline const gl::ProgramPipelineID *
1169 GetParamVal<ParamType::TProgramPipelineIDConstPointer, const gl::ProgramPipelineID *>(
1170     const ParamValue &value)
1171 {
1172     return value.ProgramPipelineIDConstPointerVal;
1173 }
1174 
1175 template <>
1176 inline gl::ProgramPipelineID *
1177 GetParamVal<ParamType::TProgramPipelineIDPointer, gl::ProgramPipelineID *>(const ParamValue &value)
1178 {
1179     return value.ProgramPipelineIDPointerVal;
1180 }
1181 
1182 template <>
1183 inline gl::ProvokingVertexConvention
1184 GetParamVal<ParamType::TProvokingVertexConvention, gl::ProvokingVertexConvention>(
1185     const ParamValue &value)
1186 {
1187     return value.ProvokingVertexConventionVal;
1188 }
1189 
1190 template <>
1191 inline gl::QueryID GetParamVal<ParamType::TQueryID, gl::QueryID>(const ParamValue &value)
1192 {
1193     return value.QueryIDVal;
1194 }
1195 
1196 template <>
1197 inline const gl::QueryID *GetParamVal<ParamType::TQueryIDConstPointer, const gl::QueryID *>(
1198     const ParamValue &value)
1199 {
1200     return value.QueryIDConstPointerVal;
1201 }
1202 
1203 template <>
1204 inline gl::QueryID *GetParamVal<ParamType::TQueryIDPointer, gl::QueryID *>(const ParamValue &value)
1205 {
1206     return value.QueryIDPointerVal;
1207 }
1208 
1209 template <>
1210 inline gl::QueryType GetParamVal<ParamType::TQueryType, gl::QueryType>(const ParamValue &value)
1211 {
1212     return value.QueryTypeVal;
1213 }
1214 
1215 template <>
1216 inline gl::RenderbufferID GetParamVal<ParamType::TRenderbufferID, gl::RenderbufferID>(
1217     const ParamValue &value)
1218 {
1219     return value.RenderbufferIDVal;
1220 }
1221 
1222 template <>
1223 inline const gl::RenderbufferID *GetParamVal<ParamType::TRenderbufferIDConstPointer,
1224                                              const gl::RenderbufferID *>(const ParamValue &value)
1225 {
1226     return value.RenderbufferIDConstPointerVal;
1227 }
1228 
1229 template <>
1230 inline gl::RenderbufferID *GetParamVal<ParamType::TRenderbufferIDPointer, gl::RenderbufferID *>(
1231     const ParamValue &value)
1232 {
1233     return value.RenderbufferIDPointerVal;
1234 }
1235 
1236 template <>
1237 inline gl::SamplerID GetParamVal<ParamType::TSamplerID, gl::SamplerID>(const ParamValue &value)
1238 {
1239     return value.SamplerIDVal;
1240 }
1241 
1242 template <>
1243 inline const gl::SamplerID *GetParamVal<ParamType::TSamplerIDConstPointer, const gl::SamplerID *>(
1244     const ParamValue &value)
1245 {
1246     return value.SamplerIDConstPointerVal;
1247 }
1248 
1249 template <>
1250 inline gl::SamplerID *GetParamVal<ParamType::TSamplerIDPointer, gl::SamplerID *>(
1251     const ParamValue &value)
1252 {
1253     return value.SamplerIDPointerVal;
1254 }
1255 
1256 template <>
1257 inline gl::SemaphoreID GetParamVal<ParamType::TSemaphoreID, gl::SemaphoreID>(
1258     const ParamValue &value)
1259 {
1260     return value.SemaphoreIDVal;
1261 }
1262 
1263 template <>
1264 inline const gl::SemaphoreID *
1265 GetParamVal<ParamType::TSemaphoreIDConstPointer, const gl::SemaphoreID *>(const ParamValue &value)
1266 {
1267     return value.SemaphoreIDConstPointerVal;
1268 }
1269 
1270 template <>
1271 inline gl::SemaphoreID *GetParamVal<ParamType::TSemaphoreIDPointer, gl::SemaphoreID *>(
1272     const ParamValue &value)
1273 {
1274     return value.SemaphoreIDPointerVal;
1275 }
1276 
1277 template <>
1278 inline gl::ShaderProgramID GetParamVal<ParamType::TShaderProgramID, gl::ShaderProgramID>(
1279     const ParamValue &value)
1280 {
1281     return value.ShaderProgramIDVal;
1282 }
1283 
1284 template <>
1285 inline const gl::ShaderProgramID *GetParamVal<ParamType::TShaderProgramIDConstPointer,
1286                                               const gl::ShaderProgramID *>(const ParamValue &value)
1287 {
1288     return value.ShaderProgramIDConstPointerVal;
1289 }
1290 
1291 template <>
1292 inline gl::ShaderProgramID *GetParamVal<ParamType::TShaderProgramIDPointer, gl::ShaderProgramID *>(
1293     const ParamValue &value)
1294 {
1295     return value.ShaderProgramIDPointerVal;
1296 }
1297 
1298 template <>
1299 inline gl::ShaderType GetParamVal<ParamType::TShaderType, gl::ShaderType>(const ParamValue &value)
1300 {
1301     return value.ShaderTypeVal;
1302 }
1303 
1304 template <>
1305 inline gl::ShadingModel GetParamVal<ParamType::TShadingModel, gl::ShadingModel>(
1306     const ParamValue &value)
1307 {
1308     return value.ShadingModelVal;
1309 }
1310 
1311 template <>
1312 inline egl::SurfaceID GetParamVal<ParamType::TSurfaceID, egl::SurfaceID>(const ParamValue &value)
1313 {
1314     return value.SurfaceIDVal;
1315 }
1316 
1317 template <>
1318 inline gl::SyncID GetParamVal<ParamType::TSyncID, gl::SyncID>(const ParamValue &value)
1319 {
1320     return value.SyncIDVal;
1321 }
1322 
1323 template <>
1324 inline gl::TextureEnvParameter
1325 GetParamVal<ParamType::TTextureEnvParameter, gl::TextureEnvParameter>(const ParamValue &value)
1326 {
1327     return value.TextureEnvParameterVal;
1328 }
1329 
1330 template <>
1331 inline gl::TextureEnvTarget GetParamVal<ParamType::TTextureEnvTarget, gl::TextureEnvTarget>(
1332     const ParamValue &value)
1333 {
1334     return value.TextureEnvTargetVal;
1335 }
1336 
1337 template <>
1338 inline gl::TextureID GetParamVal<ParamType::TTextureID, gl::TextureID>(const ParamValue &value)
1339 {
1340     return value.TextureIDVal;
1341 }
1342 
1343 template <>
1344 inline const gl::TextureID *GetParamVal<ParamType::TTextureIDConstPointer, const gl::TextureID *>(
1345     const ParamValue &value)
1346 {
1347     return value.TextureIDConstPointerVal;
1348 }
1349 
1350 template <>
1351 inline gl::TextureID *GetParamVal<ParamType::TTextureIDPointer, gl::TextureID *>(
1352     const ParamValue &value)
1353 {
1354     return value.TextureIDPointerVal;
1355 }
1356 
1357 template <>
1358 inline gl::TextureTarget GetParamVal<ParamType::TTextureTarget, gl::TextureTarget>(
1359     const ParamValue &value)
1360 {
1361     return value.TextureTargetVal;
1362 }
1363 
1364 template <>
1365 inline gl::TextureType GetParamVal<ParamType::TTextureType, gl::TextureType>(
1366     const ParamValue &value)
1367 {
1368     return value.TextureTypeVal;
1369 }
1370 
1371 template <>
1372 inline egl::Timestamp GetParamVal<ParamType::TTimestamp, egl::Timestamp>(const ParamValue &value)
1373 {
1374     return value.TimestampVal;
1375 }
1376 
1377 template <>
1378 inline gl::TransformFeedbackID
1379 GetParamVal<ParamType::TTransformFeedbackID, gl::TransformFeedbackID>(const ParamValue &value)
1380 {
1381     return value.TransformFeedbackIDVal;
1382 }
1383 
1384 template <>
1385 inline const gl::TransformFeedbackID *
1386 GetParamVal<ParamType::TTransformFeedbackIDConstPointer, const gl::TransformFeedbackID *>(
1387     const ParamValue &value)
1388 {
1389     return value.TransformFeedbackIDConstPointerVal;
1390 }
1391 
1392 template <>
1393 inline gl::TransformFeedbackID *GetParamVal<ParamType::TTransformFeedbackIDPointer,
1394                                             gl::TransformFeedbackID *>(const ParamValue &value)
1395 {
1396     return value.TransformFeedbackIDPointerVal;
1397 }
1398 
1399 template <>
1400 inline gl::UniformBlockIndex GetParamVal<ParamType::TUniformBlockIndex, gl::UniformBlockIndex>(
1401     const ParamValue &value)
1402 {
1403     return value.UniformBlockIndexVal;
1404 }
1405 
1406 template <>
1407 inline gl::UniformLocation GetParamVal<ParamType::TUniformLocation, gl::UniformLocation>(
1408     const ParamValue &value)
1409 {
1410     return value.UniformLocationVal;
1411 }
1412 
1413 template <>
1414 inline gl::VertexArrayID GetParamVal<ParamType::TVertexArrayID, gl::VertexArrayID>(
1415     const ParamValue &value)
1416 {
1417     return value.VertexArrayIDVal;
1418 }
1419 
1420 template <>
1421 inline const gl::VertexArrayID *GetParamVal<ParamType::TVertexArrayIDConstPointer,
1422                                             const gl::VertexArrayID *>(const ParamValue &value)
1423 {
1424     return value.VertexArrayIDConstPointerVal;
1425 }
1426 
1427 template <>
1428 inline gl::VertexArrayID *GetParamVal<ParamType::TVertexArrayIDPointer, gl::VertexArrayID *>(
1429     const ParamValue &value)
1430 {
1431     return value.VertexArrayIDPointerVal;
1432 }
1433 
1434 template <>
1435 inline gl::VertexAttribType GetParamVal<ParamType::TVertexAttribType, gl::VertexAttribType>(
1436     const ParamValue &value)
1437 {
1438     return value.VertexAttribTypeVal;
1439 }
1440 
1441 template <>
1442 inline const char *GetParamVal<ParamType::TcharConstPointer, const char *>(const ParamValue &value)
1443 {
1444     return value.charConstPointerVal;
1445 }
1446 
1447 template <>
1448 inline egl::Config *GetParamVal<ParamType::Tegl_ConfigPointer, egl::Config *>(
1449     const ParamValue &value)
1450 {
1451     return value.egl_ConfigPointerVal;
1452 }
1453 
1454 template <>
1455 inline egl::Device *GetParamVal<ParamType::Tegl_DevicePointer, egl::Device *>(
1456     const ParamValue &value)
1457 {
1458     return value.egl_DevicePointerVal;
1459 }
1460 
1461 template <>
1462 inline egl::Display *GetParamVal<ParamType::Tegl_DisplayPointer, egl::Display *>(
1463     const ParamValue &value)
1464 {
1465     return value.egl_DisplayPointerVal;
1466 }
1467 
1468 template <>
1469 inline egl::Stream *GetParamVal<ParamType::Tegl_StreamPointer, egl::Stream *>(
1470     const ParamValue &value)
1471 {
1472     return value.egl_StreamPointerVal;
1473 }
1474 
1475 template <>
1476 inline egl::SyncID GetParamVal<ParamType::Tegl_SyncID, egl::SyncID>(const ParamValue &value)
1477 {
1478     return value.egl_SyncIDVal;
1479 }
1480 
1481 template <>
1482 inline const void *GetParamVal<ParamType::TvoidConstPointer, const void *>(const ParamValue &value)
1483 {
1484     return value.voidConstPointerVal;
1485 }
1486 
1487 template <>
1488 inline const void *const *GetParamVal<ParamType::TvoidConstPointerPointer, const void *const *>(
1489     const ParamValue &value)
1490 {
1491     return value.voidConstPointerPointerVal;
1492 }
1493 
1494 template <>
1495 inline void *GetParamVal<ParamType::TvoidPointer, void *>(const ParamValue &value)
1496 {
1497     return value.voidPointerVal;
1498 }
1499 
1500 template <>
1501 inline void **GetParamVal<ParamType::TvoidPointerPointer, void **>(const ParamValue &value)
1502 {
1503     return value.voidPointerPointerVal;
1504 }
1505 
1506 template <ParamType PType, typename T>
GetParamVal(const ParamValue & value)1507 T GetParamVal(const ParamValue &value)
1508 {
1509     UNREACHABLE();
1510     return T();
1511 }
1512 
1513 template <typename T>
AccessParamValue(ParamType paramType,const ParamValue & value)1514 T AccessParamValue(ParamType paramType, const ParamValue &value)
1515 {
1516     switch (paramType)
1517     {
1518         case ParamType::TAHardwareBufferConstPointer:
1519             return GetParamVal<ParamType::TAHardwareBufferConstPointer, T>(value);
1520         case ParamType::TAlphaTestFunc:
1521             return GetParamVal<ParamType::TAlphaTestFunc, T>(value);
1522         case ParamType::TBufferBinding:
1523             return GetParamVal<ParamType::TBufferBinding, T>(value);
1524         case ParamType::TBufferID:
1525             return GetParamVal<ParamType::TBufferID, T>(value);
1526         case ParamType::TBufferIDConstPointer:
1527             return GetParamVal<ParamType::TBufferIDConstPointer, T>(value);
1528         case ParamType::TBufferIDPointer:
1529             return GetParamVal<ParamType::TBufferIDPointer, T>(value);
1530         case ParamType::TBufferUsage:
1531             return GetParamVal<ParamType::TBufferUsage, T>(value);
1532         case ParamType::TClientVertexArrayType:
1533             return GetParamVal<ParamType::TClientVertexArrayType, T>(value);
1534         case ParamType::TClipDepthMode:
1535             return GetParamVal<ParamType::TClipDepthMode, T>(value);
1536         case ParamType::TClipOrigin:
1537             return GetParamVal<ParamType::TClipOrigin, T>(value);
1538         case ParamType::TCompositorTiming:
1539             return GetParamVal<ParamType::TCompositorTiming, T>(value);
1540         case ParamType::TContextID:
1541             return GetParamVal<ParamType::TContextID, T>(value);
1542         case ParamType::TCullFaceMode:
1543             return GetParamVal<ParamType::TCullFaceMode, T>(value);
1544         case ParamType::TDrawElementsType:
1545             return GetParamVal<ParamType::TDrawElementsType, T>(value);
1546         case ParamType::TEGLAttribConstPointer:
1547             return GetParamVal<ParamType::TEGLAttribConstPointer, T>(value);
1548         case ParamType::TEGLAttribKHRPointer:
1549             return GetParamVal<ParamType::TEGLAttribKHRPointer, T>(value);
1550         case ParamType::TEGLAttribPointer:
1551             return GetParamVal<ParamType::TEGLAttribPointer, T>(value);
1552         case ParamType::TEGLBoolean:
1553             return GetParamVal<ParamType::TEGLBoolean, T>(value);
1554         case ParamType::TEGLBooleanPointer:
1555             return GetParamVal<ParamType::TEGLBooleanPointer, T>(value);
1556         case ParamType::TEGLClientBuffer:
1557             return GetParamVal<ParamType::TEGLClientBuffer, T>(value);
1558         case ParamType::TEGLConfigPointer:
1559             return GetParamVal<ParamType::TEGLConfigPointer, T>(value);
1560         case ParamType::TEGLContext:
1561             return GetParamVal<ParamType::TEGLContext, T>(value);
1562         case ParamType::TEGLDEBUGPROCKHR:
1563             return GetParamVal<ParamType::TEGLDEBUGPROCKHR, T>(value);
1564         case ParamType::TEGLDeviceEXT:
1565             return GetParamVal<ParamType::TEGLDeviceEXT, T>(value);
1566         case ParamType::TEGLDisplay:
1567             return GetParamVal<ParamType::TEGLDisplay, T>(value);
1568         case ParamType::TEGLFrameTokenANGLE:
1569             return GetParamVal<ParamType::TEGLFrameTokenANGLE, T>(value);
1570         case ParamType::TEGLGetBlobFuncANDROID:
1571             return GetParamVal<ParamType::TEGLGetBlobFuncANDROID, T>(value);
1572         case ParamType::TEGLImage:
1573             return GetParamVal<ParamType::TEGLImage, T>(value);
1574         case ParamType::TEGLImageKHR:
1575             return GetParamVal<ParamType::TEGLImageKHR, T>(value);
1576         case ParamType::TEGLLabelKHR:
1577             return GetParamVal<ParamType::TEGLLabelKHR, T>(value);
1578         case ParamType::TEGLNativeDisplayType:
1579             return GetParamVal<ParamType::TEGLNativeDisplayType, T>(value);
1580         case ParamType::TEGLNativePixmapType:
1581             return GetParamVal<ParamType::TEGLNativePixmapType, T>(value);
1582         case ParamType::TEGLNativeWindowType:
1583             return GetParamVal<ParamType::TEGLNativeWindowType, T>(value);
1584         case ParamType::TEGLObjectKHR:
1585             return GetParamVal<ParamType::TEGLObjectKHR, T>(value);
1586         case ParamType::TEGLSetBlobFuncANDROID:
1587             return GetParamVal<ParamType::TEGLSetBlobFuncANDROID, T>(value);
1588         case ParamType::TEGLStreamKHR:
1589             return GetParamVal<ParamType::TEGLStreamKHR, T>(value);
1590         case ParamType::TEGLSurface:
1591             return GetParamVal<ParamType::TEGLSurface, T>(value);
1592         case ParamType::TEGLSync:
1593             return GetParamVal<ParamType::TEGLSync, T>(value);
1594         case ParamType::TEGLSyncKHR:
1595             return GetParamVal<ParamType::TEGLSyncKHR, T>(value);
1596         case ParamType::TEGLTime:
1597             return GetParamVal<ParamType::TEGLTime, T>(value);
1598         case ParamType::TEGLTimeKHR:
1599             return GetParamVal<ParamType::TEGLTimeKHR, T>(value);
1600         case ParamType::TEGLenum:
1601             return GetParamVal<ParamType::TEGLenum, T>(value);
1602         case ParamType::TEGLint:
1603             return GetParamVal<ParamType::TEGLint, T>(value);
1604         case ParamType::TEGLintConstPointer:
1605             return GetParamVal<ParamType::TEGLintConstPointer, T>(value);
1606         case ParamType::TEGLintPointer:
1607             return GetParamVal<ParamType::TEGLintPointer, T>(value);
1608         case ParamType::TEGLnsecsANDROID:
1609             return GetParamVal<ParamType::TEGLnsecsANDROID, T>(value);
1610         case ParamType::TEGLnsecsANDROIDPointer:
1611             return GetParamVal<ParamType::TEGLnsecsANDROIDPointer, T>(value);
1612         case ParamType::TEGLuint64KHR:
1613             return GetParamVal<ParamType::TEGLuint64KHR, T>(value);
1614         case ParamType::TEGLuint64KHRPointer:
1615             return GetParamVal<ParamType::TEGLuint64KHRPointer, T>(value);
1616         case ParamType::TFenceNVID:
1617             return GetParamVal<ParamType::TFenceNVID, T>(value);
1618         case ParamType::TFenceNVIDConstPointer:
1619             return GetParamVal<ParamType::TFenceNVIDConstPointer, T>(value);
1620         case ParamType::TFenceNVIDPointer:
1621             return GetParamVal<ParamType::TFenceNVIDPointer, T>(value);
1622         case ParamType::TFramebufferID:
1623             return GetParamVal<ParamType::TFramebufferID, T>(value);
1624         case ParamType::TFramebufferIDConstPointer:
1625             return GetParamVal<ParamType::TFramebufferIDConstPointer, T>(value);
1626         case ParamType::TFramebufferIDPointer:
1627             return GetParamVal<ParamType::TFramebufferIDPointer, T>(value);
1628         case ParamType::TGLDEBUGPROC:
1629             return GetParamVal<ParamType::TGLDEBUGPROC, T>(value);
1630         case ParamType::TGLDEBUGPROCKHR:
1631             return GetParamVal<ParamType::TGLDEBUGPROCKHR, T>(value);
1632         case ParamType::TGLbitfield:
1633             return GetParamVal<ParamType::TGLbitfield, T>(value);
1634         case ParamType::TGLboolean:
1635             return GetParamVal<ParamType::TGLboolean, T>(value);
1636         case ParamType::TGLbooleanConstPointer:
1637             return GetParamVal<ParamType::TGLbooleanConstPointer, T>(value);
1638         case ParamType::TGLbooleanPointer:
1639             return GetParamVal<ParamType::TGLbooleanPointer, T>(value);
1640         case ParamType::TGLbyte:
1641             return GetParamVal<ParamType::TGLbyte, T>(value);
1642         case ParamType::TGLbyteConstPointer:
1643             return GetParamVal<ParamType::TGLbyteConstPointer, T>(value);
1644         case ParamType::TGLcharConstPointer:
1645             return GetParamVal<ParamType::TGLcharConstPointer, T>(value);
1646         case ParamType::TGLcharConstPointerPointer:
1647             return GetParamVal<ParamType::TGLcharConstPointerPointer, T>(value);
1648         case ParamType::TGLcharPointer:
1649             return GetParamVal<ParamType::TGLcharPointer, T>(value);
1650         case ParamType::TGLclampx:
1651             return GetParamVal<ParamType::TGLclampx, T>(value);
1652         case ParamType::TGLdouble:
1653             return GetParamVal<ParamType::TGLdouble, T>(value);
1654         case ParamType::TGLdoubleConstPointer:
1655             return GetParamVal<ParamType::TGLdoubleConstPointer, T>(value);
1656         case ParamType::TGLdoublePointer:
1657             return GetParamVal<ParamType::TGLdoublePointer, T>(value);
1658         case ParamType::TGLeglClientBufferEXT:
1659             return GetParamVal<ParamType::TGLeglClientBufferEXT, T>(value);
1660         case ParamType::TGLenum:
1661             return GetParamVal<ParamType::TGLenum, T>(value);
1662         case ParamType::TGLenumConstPointer:
1663             return GetParamVal<ParamType::TGLenumConstPointer, T>(value);
1664         case ParamType::TGLenumPointer:
1665             return GetParamVal<ParamType::TGLenumPointer, T>(value);
1666         case ParamType::TGLfixed:
1667             return GetParamVal<ParamType::TGLfixed, T>(value);
1668         case ParamType::TGLfixedConstPointer:
1669             return GetParamVal<ParamType::TGLfixedConstPointer, T>(value);
1670         case ParamType::TGLfixedPointer:
1671             return GetParamVal<ParamType::TGLfixedPointer, T>(value);
1672         case ParamType::TGLfloat:
1673             return GetParamVal<ParamType::TGLfloat, T>(value);
1674         case ParamType::TGLfloatConstPointer:
1675             return GetParamVal<ParamType::TGLfloatConstPointer, T>(value);
1676         case ParamType::TGLfloatPointer:
1677             return GetParamVal<ParamType::TGLfloatPointer, T>(value);
1678         case ParamType::TGLint:
1679             return GetParamVal<ParamType::TGLint, T>(value);
1680         case ParamType::TGLint64:
1681             return GetParamVal<ParamType::TGLint64, T>(value);
1682         case ParamType::TGLint64Pointer:
1683             return GetParamVal<ParamType::TGLint64Pointer, T>(value);
1684         case ParamType::TGLintConstPointer:
1685             return GetParamVal<ParamType::TGLintConstPointer, T>(value);
1686         case ParamType::TGLintPointer:
1687             return GetParamVal<ParamType::TGLintPointer, T>(value);
1688         case ParamType::TGLintptr:
1689             return GetParamVal<ParamType::TGLintptr, T>(value);
1690         case ParamType::TGLintptrConstPointer:
1691             return GetParamVal<ParamType::TGLintptrConstPointer, T>(value);
1692         case ParamType::TGLshort:
1693             return GetParamVal<ParamType::TGLshort, T>(value);
1694         case ParamType::TGLshortConstPointer:
1695             return GetParamVal<ParamType::TGLshortConstPointer, T>(value);
1696         case ParamType::TGLsizei:
1697             return GetParamVal<ParamType::TGLsizei, T>(value);
1698         case ParamType::TGLsizeiConstPointer:
1699             return GetParamVal<ParamType::TGLsizeiConstPointer, T>(value);
1700         case ParamType::TGLsizeiPointer:
1701             return GetParamVal<ParamType::TGLsizeiPointer, T>(value);
1702         case ParamType::TGLsizeiptr:
1703             return GetParamVal<ParamType::TGLsizeiptr, T>(value);
1704         case ParamType::TGLsizeiptrConstPointer:
1705             return GetParamVal<ParamType::TGLsizeiptrConstPointer, T>(value);
1706         case ParamType::TGLsync:
1707             return GetParamVal<ParamType::TGLsync, T>(value);
1708         case ParamType::TGLubyte:
1709             return GetParamVal<ParamType::TGLubyte, T>(value);
1710         case ParamType::TGLubyteConstPointer:
1711             return GetParamVal<ParamType::TGLubyteConstPointer, T>(value);
1712         case ParamType::TGLubytePointer:
1713             return GetParamVal<ParamType::TGLubytePointer, T>(value);
1714         case ParamType::TGLuint:
1715             return GetParamVal<ParamType::TGLuint, T>(value);
1716         case ParamType::TGLuint64:
1717             return GetParamVal<ParamType::TGLuint64, T>(value);
1718         case ParamType::TGLuint64ConstPointer:
1719             return GetParamVal<ParamType::TGLuint64ConstPointer, T>(value);
1720         case ParamType::TGLuint64Pointer:
1721             return GetParamVal<ParamType::TGLuint64Pointer, T>(value);
1722         case ParamType::TGLuintConstPointer:
1723             return GetParamVal<ParamType::TGLuintConstPointer, T>(value);
1724         case ParamType::TGLuintPointer:
1725             return GetParamVal<ParamType::TGLuintPointer, T>(value);
1726         case ParamType::TGLushort:
1727             return GetParamVal<ParamType::TGLushort, T>(value);
1728         case ParamType::TGLushortConstPointer:
1729             return GetParamVal<ParamType::TGLushortConstPointer, T>(value);
1730         case ParamType::TGLushortPointer:
1731             return GetParamVal<ParamType::TGLushortPointer, T>(value);
1732         case ParamType::TGraphicsResetStatus:
1733             return GetParamVal<ParamType::TGraphicsResetStatus, T>(value);
1734         case ParamType::THandleType:
1735             return GetParamVal<ParamType::THandleType, T>(value);
1736         case ParamType::TImageID:
1737             return GetParamVal<ParamType::TImageID, T>(value);
1738         case ParamType::TLightParameter:
1739             return GetParamVal<ParamType::TLightParameter, T>(value);
1740         case ParamType::TLogicalOperation:
1741             return GetParamVal<ParamType::TLogicalOperation, T>(value);
1742         case ParamType::TMaterialParameter:
1743             return GetParamVal<ParamType::TMaterialParameter, T>(value);
1744         case ParamType::TMatrixType:
1745             return GetParamVal<ParamType::TMatrixType, T>(value);
1746         case ParamType::TMemoryObjectID:
1747             return GetParamVal<ParamType::TMemoryObjectID, T>(value);
1748         case ParamType::TMemoryObjectIDConstPointer:
1749             return GetParamVal<ParamType::TMemoryObjectIDConstPointer, T>(value);
1750         case ParamType::TMemoryObjectIDPointer:
1751             return GetParamVal<ParamType::TMemoryObjectIDPointer, T>(value);
1752         case ParamType::TObjectType:
1753             return GetParamVal<ParamType::TObjectType, T>(value);
1754         case ParamType::TPointParameter:
1755             return GetParamVal<ParamType::TPointParameter, T>(value);
1756         case ParamType::TPolygonMode:
1757             return GetParamVal<ParamType::TPolygonMode, T>(value);
1758         case ParamType::TPrimitiveMode:
1759             return GetParamVal<ParamType::TPrimitiveMode, T>(value);
1760         case ParamType::TProgramPipelineID:
1761             return GetParamVal<ParamType::TProgramPipelineID, T>(value);
1762         case ParamType::TProgramPipelineIDConstPointer:
1763             return GetParamVal<ParamType::TProgramPipelineIDConstPointer, T>(value);
1764         case ParamType::TProgramPipelineIDPointer:
1765             return GetParamVal<ParamType::TProgramPipelineIDPointer, T>(value);
1766         case ParamType::TProvokingVertexConvention:
1767             return GetParamVal<ParamType::TProvokingVertexConvention, T>(value);
1768         case ParamType::TQueryID:
1769             return GetParamVal<ParamType::TQueryID, T>(value);
1770         case ParamType::TQueryIDConstPointer:
1771             return GetParamVal<ParamType::TQueryIDConstPointer, T>(value);
1772         case ParamType::TQueryIDPointer:
1773             return GetParamVal<ParamType::TQueryIDPointer, T>(value);
1774         case ParamType::TQueryType:
1775             return GetParamVal<ParamType::TQueryType, T>(value);
1776         case ParamType::TRenderbufferID:
1777             return GetParamVal<ParamType::TRenderbufferID, T>(value);
1778         case ParamType::TRenderbufferIDConstPointer:
1779             return GetParamVal<ParamType::TRenderbufferIDConstPointer, T>(value);
1780         case ParamType::TRenderbufferIDPointer:
1781             return GetParamVal<ParamType::TRenderbufferIDPointer, T>(value);
1782         case ParamType::TSamplerID:
1783             return GetParamVal<ParamType::TSamplerID, T>(value);
1784         case ParamType::TSamplerIDConstPointer:
1785             return GetParamVal<ParamType::TSamplerIDConstPointer, T>(value);
1786         case ParamType::TSamplerIDPointer:
1787             return GetParamVal<ParamType::TSamplerIDPointer, T>(value);
1788         case ParamType::TSemaphoreID:
1789             return GetParamVal<ParamType::TSemaphoreID, T>(value);
1790         case ParamType::TSemaphoreIDConstPointer:
1791             return GetParamVal<ParamType::TSemaphoreIDConstPointer, T>(value);
1792         case ParamType::TSemaphoreIDPointer:
1793             return GetParamVal<ParamType::TSemaphoreIDPointer, T>(value);
1794         case ParamType::TShaderProgramID:
1795             return GetParamVal<ParamType::TShaderProgramID, T>(value);
1796         case ParamType::TShaderProgramIDConstPointer:
1797             return GetParamVal<ParamType::TShaderProgramIDConstPointer, T>(value);
1798         case ParamType::TShaderProgramIDPointer:
1799             return GetParamVal<ParamType::TShaderProgramIDPointer, T>(value);
1800         case ParamType::TShaderType:
1801             return GetParamVal<ParamType::TShaderType, T>(value);
1802         case ParamType::TShadingModel:
1803             return GetParamVal<ParamType::TShadingModel, T>(value);
1804         case ParamType::TSurfaceID:
1805             return GetParamVal<ParamType::TSurfaceID, T>(value);
1806         case ParamType::TSyncID:
1807             return GetParamVal<ParamType::TSyncID, T>(value);
1808         case ParamType::TTextureEnvParameter:
1809             return GetParamVal<ParamType::TTextureEnvParameter, T>(value);
1810         case ParamType::TTextureEnvTarget:
1811             return GetParamVal<ParamType::TTextureEnvTarget, T>(value);
1812         case ParamType::TTextureID:
1813             return GetParamVal<ParamType::TTextureID, T>(value);
1814         case ParamType::TTextureIDConstPointer:
1815             return GetParamVal<ParamType::TTextureIDConstPointer, T>(value);
1816         case ParamType::TTextureIDPointer:
1817             return GetParamVal<ParamType::TTextureIDPointer, T>(value);
1818         case ParamType::TTextureTarget:
1819             return GetParamVal<ParamType::TTextureTarget, T>(value);
1820         case ParamType::TTextureType:
1821             return GetParamVal<ParamType::TTextureType, T>(value);
1822         case ParamType::TTimestamp:
1823             return GetParamVal<ParamType::TTimestamp, T>(value);
1824         case ParamType::TTransformFeedbackID:
1825             return GetParamVal<ParamType::TTransformFeedbackID, T>(value);
1826         case ParamType::TTransformFeedbackIDConstPointer:
1827             return GetParamVal<ParamType::TTransformFeedbackIDConstPointer, T>(value);
1828         case ParamType::TTransformFeedbackIDPointer:
1829             return GetParamVal<ParamType::TTransformFeedbackIDPointer, T>(value);
1830         case ParamType::TUniformBlockIndex:
1831             return GetParamVal<ParamType::TUniformBlockIndex, T>(value);
1832         case ParamType::TUniformLocation:
1833             return GetParamVal<ParamType::TUniformLocation, T>(value);
1834         case ParamType::TVertexArrayID:
1835             return GetParamVal<ParamType::TVertexArrayID, T>(value);
1836         case ParamType::TVertexArrayIDConstPointer:
1837             return GetParamVal<ParamType::TVertexArrayIDConstPointer, T>(value);
1838         case ParamType::TVertexArrayIDPointer:
1839             return GetParamVal<ParamType::TVertexArrayIDPointer, T>(value);
1840         case ParamType::TVertexAttribType:
1841             return GetParamVal<ParamType::TVertexAttribType, T>(value);
1842         case ParamType::TcharConstPointer:
1843             return GetParamVal<ParamType::TcharConstPointer, T>(value);
1844         case ParamType::Tegl_ConfigPointer:
1845             return GetParamVal<ParamType::Tegl_ConfigPointer, T>(value);
1846         case ParamType::Tegl_DevicePointer:
1847             return GetParamVal<ParamType::Tegl_DevicePointer, T>(value);
1848         case ParamType::Tegl_DisplayPointer:
1849             return GetParamVal<ParamType::Tegl_DisplayPointer, T>(value);
1850         case ParamType::Tegl_StreamPointer:
1851             return GetParamVal<ParamType::Tegl_StreamPointer, T>(value);
1852         case ParamType::Tegl_SyncID:
1853             return GetParamVal<ParamType::Tegl_SyncID, T>(value);
1854         case ParamType::TvoidConstPointer:
1855             return GetParamVal<ParamType::TvoidConstPointer, T>(value);
1856         case ParamType::TvoidConstPointerPointer:
1857             return GetParamVal<ParamType::TvoidConstPointerPointer, T>(value);
1858         case ParamType::TvoidPointer:
1859             return GetParamVal<ParamType::TvoidPointer, T>(value);
1860         case ParamType::TvoidPointerPointer:
1861             return GetParamVal<ParamType::TvoidPointerPointer, T>(value);
1862     }
1863     UNREACHABLE();
1864     return T();
1865 }
1866 
1867 template <ParamType PType, typename T>
1868 void SetParamVal(T valueIn, ParamValue *valueOut);
1869 
1870 template <>
1871 inline void SetParamVal<ParamType::TAHardwareBufferConstPointer>(const AHardwareBuffer *valueIn,
1872                                                                  ParamValue *valueOut)
1873 {
1874     valueOut->AHardwareBufferConstPointerVal = valueIn;
1875 }
1876 
1877 template <>
1878 inline void SetParamVal<ParamType::TAlphaTestFunc>(gl::AlphaTestFunc valueIn, ParamValue *valueOut)
1879 {
1880     valueOut->AlphaTestFuncVal = valueIn;
1881 }
1882 
1883 template <>
1884 inline void SetParamVal<ParamType::TBufferBinding>(gl::BufferBinding valueIn, ParamValue *valueOut)
1885 {
1886     valueOut->BufferBindingVal = valueIn;
1887 }
1888 
1889 template <>
1890 inline void SetParamVal<ParamType::TBufferID>(gl::BufferID valueIn, ParamValue *valueOut)
1891 {
1892     valueOut->BufferIDVal = valueIn;
1893 }
1894 
1895 template <>
1896 inline void SetParamVal<ParamType::TBufferIDConstPointer>(const gl::BufferID *valueIn,
1897                                                           ParamValue *valueOut)
1898 {
1899     valueOut->BufferIDConstPointerVal = valueIn;
1900 }
1901 
1902 template <>
1903 inline void SetParamVal<ParamType::TBufferIDPointer>(gl::BufferID *valueIn, ParamValue *valueOut)
1904 {
1905     valueOut->BufferIDPointerVal = valueIn;
1906 }
1907 
1908 template <>
1909 inline void SetParamVal<ParamType::TBufferUsage>(gl::BufferUsage valueIn, ParamValue *valueOut)
1910 {
1911     valueOut->BufferUsageVal = valueIn;
1912 }
1913 
1914 template <>
1915 inline void SetParamVal<ParamType::TClientVertexArrayType>(gl::ClientVertexArrayType valueIn,
1916                                                            ParamValue *valueOut)
1917 {
1918     valueOut->ClientVertexArrayTypeVal = valueIn;
1919 }
1920 
1921 template <>
1922 inline void SetParamVal<ParamType::TClipDepthMode>(gl::ClipDepthMode valueIn, ParamValue *valueOut)
1923 {
1924     valueOut->ClipDepthModeVal = valueIn;
1925 }
1926 
1927 template <>
1928 inline void SetParamVal<ParamType::TClipOrigin>(gl::ClipOrigin valueIn, ParamValue *valueOut)
1929 {
1930     valueOut->ClipOriginVal = valueIn;
1931 }
1932 
1933 template <>
1934 inline void SetParamVal<ParamType::TCompositorTiming>(egl::CompositorTiming valueIn,
1935                                                       ParamValue *valueOut)
1936 {
1937     valueOut->CompositorTimingVal = valueIn;
1938 }
1939 
1940 template <>
1941 inline void SetParamVal<ParamType::TContextID>(gl::ContextID valueIn, ParamValue *valueOut)
1942 {
1943     valueOut->ContextIDVal = valueIn;
1944 }
1945 
1946 template <>
1947 inline void SetParamVal<ParamType::TCullFaceMode>(gl::CullFaceMode valueIn, ParamValue *valueOut)
1948 {
1949     valueOut->CullFaceModeVal = valueIn;
1950 }
1951 
1952 template <>
1953 inline void SetParamVal<ParamType::TDrawElementsType>(gl::DrawElementsType valueIn,
1954                                                       ParamValue *valueOut)
1955 {
1956     valueOut->DrawElementsTypeVal = valueIn;
1957 }
1958 
1959 template <>
1960 inline void SetParamVal<ParamType::TEGLAttribConstPointer>(const EGLAttrib *valueIn,
1961                                                            ParamValue *valueOut)
1962 {
1963     valueOut->EGLAttribConstPointerVal = valueIn;
1964 }
1965 
1966 template <>
1967 inline void SetParamVal<ParamType::TEGLAttribKHRPointer>(EGLAttribKHR *valueIn,
1968                                                          ParamValue *valueOut)
1969 {
1970     valueOut->EGLAttribKHRPointerVal = valueIn;
1971 }
1972 
1973 template <>
1974 inline void SetParamVal<ParamType::TEGLAttribPointer>(EGLAttrib *valueIn, ParamValue *valueOut)
1975 {
1976     valueOut->EGLAttribPointerVal = valueIn;
1977 }
1978 
1979 template <>
1980 inline void SetParamVal<ParamType::TEGLBoolean>(EGLBoolean valueIn, ParamValue *valueOut)
1981 {
1982     valueOut->EGLBooleanVal = valueIn;
1983 }
1984 
1985 template <>
1986 inline void SetParamVal<ParamType::TEGLBooleanPointer>(EGLBoolean *valueIn, ParamValue *valueOut)
1987 {
1988     valueOut->EGLBooleanPointerVal = valueIn;
1989 }
1990 
1991 template <>
1992 inline void SetParamVal<ParamType::TEGLClientBuffer>(EGLClientBuffer valueIn, ParamValue *valueOut)
1993 {
1994     valueOut->EGLClientBufferVal = valueIn;
1995 }
1996 
1997 template <>
1998 inline void SetParamVal<ParamType::TEGLConfigPointer>(EGLConfig *valueIn, ParamValue *valueOut)
1999 {
2000     valueOut->EGLConfigPointerVal = valueIn;
2001 }
2002 
2003 template <>
2004 inline void SetParamVal<ParamType::TEGLContext>(EGLContext valueIn, ParamValue *valueOut)
2005 {
2006     valueOut->EGLContextVal = valueIn;
2007 }
2008 
2009 template <>
2010 inline void SetParamVal<ParamType::TEGLDEBUGPROCKHR>(EGLDEBUGPROCKHR valueIn, ParamValue *valueOut)
2011 {
2012     valueOut->EGLDEBUGPROCKHRVal = valueIn;
2013 }
2014 
2015 template <>
2016 inline void SetParamVal<ParamType::TEGLDeviceEXT>(EGLDeviceEXT valueIn, ParamValue *valueOut)
2017 {
2018     valueOut->EGLDeviceEXTVal = valueIn;
2019 }
2020 
2021 template <>
2022 inline void SetParamVal<ParamType::TEGLDisplay>(EGLDisplay valueIn, ParamValue *valueOut)
2023 {
2024     valueOut->EGLDisplayVal = valueIn;
2025 }
2026 
2027 template <>
2028 inline void SetParamVal<ParamType::TEGLFrameTokenANGLE>(EGLFrameTokenANGLE valueIn,
2029                                                         ParamValue *valueOut)
2030 {
2031     valueOut->EGLFrameTokenANGLEVal = valueIn;
2032 }
2033 
2034 template <>
2035 inline void SetParamVal<ParamType::TEGLGetBlobFuncANDROID>(EGLGetBlobFuncANDROID valueIn,
2036                                                            ParamValue *valueOut)
2037 {
2038     valueOut->EGLGetBlobFuncANDROIDVal = valueIn;
2039 }
2040 
2041 template <>
2042 inline void SetParamVal<ParamType::TEGLImage>(EGLImage valueIn, ParamValue *valueOut)
2043 {
2044     valueOut->EGLImageVal = valueIn;
2045 }
2046 
2047 template <>
2048 inline void SetParamVal<ParamType::TEGLImageKHR>(EGLImageKHR valueIn, ParamValue *valueOut)
2049 {
2050     valueOut->EGLImageKHRVal = valueIn;
2051 }
2052 
2053 template <>
2054 inline void SetParamVal<ParamType::TEGLLabelKHR>(EGLLabelKHR valueIn, ParamValue *valueOut)
2055 {
2056     valueOut->EGLLabelKHRVal = valueIn;
2057 }
2058 
2059 template <>
2060 inline void SetParamVal<ParamType::TEGLNativeDisplayType>(EGLNativeDisplayType valueIn,
2061                                                           ParamValue *valueOut)
2062 {
2063     valueOut->EGLNativeDisplayTypeVal = valueIn;
2064 }
2065 
2066 template <>
2067 inline void SetParamVal<ParamType::TEGLNativePixmapType>(EGLNativePixmapType valueIn,
2068                                                          ParamValue *valueOut)
2069 {
2070     valueOut->EGLNativePixmapTypeVal = valueIn;
2071 }
2072 
2073 template <>
2074 inline void SetParamVal<ParamType::TEGLNativeWindowType>(EGLNativeWindowType valueIn,
2075                                                          ParamValue *valueOut)
2076 {
2077     valueOut->EGLNativeWindowTypeVal = valueIn;
2078 }
2079 
2080 template <>
2081 inline void SetParamVal<ParamType::TEGLObjectKHR>(EGLObjectKHR valueIn, ParamValue *valueOut)
2082 {
2083     valueOut->EGLObjectKHRVal = valueIn;
2084 }
2085 
2086 template <>
2087 inline void SetParamVal<ParamType::TEGLSetBlobFuncANDROID>(EGLSetBlobFuncANDROID valueIn,
2088                                                            ParamValue *valueOut)
2089 {
2090     valueOut->EGLSetBlobFuncANDROIDVal = valueIn;
2091 }
2092 
2093 template <>
2094 inline void SetParamVal<ParamType::TEGLStreamKHR>(EGLStreamKHR valueIn, ParamValue *valueOut)
2095 {
2096     valueOut->EGLStreamKHRVal = valueIn;
2097 }
2098 
2099 template <>
2100 inline void SetParamVal<ParamType::TEGLSurface>(EGLSurface valueIn, ParamValue *valueOut)
2101 {
2102     valueOut->EGLSurfaceVal = valueIn;
2103 }
2104 
2105 template <>
2106 inline void SetParamVal<ParamType::TEGLSync>(EGLSync valueIn, ParamValue *valueOut)
2107 {
2108     valueOut->EGLSyncVal = valueIn;
2109 }
2110 
2111 template <>
2112 inline void SetParamVal<ParamType::TEGLSyncKHR>(EGLSyncKHR valueIn, ParamValue *valueOut)
2113 {
2114     valueOut->EGLSyncKHRVal = valueIn;
2115 }
2116 
2117 template <>
2118 inline void SetParamVal<ParamType::TEGLTime>(EGLTime valueIn, ParamValue *valueOut)
2119 {
2120     valueOut->EGLTimeVal = valueIn;
2121 }
2122 
2123 template <>
2124 inline void SetParamVal<ParamType::TEGLTimeKHR>(EGLTimeKHR valueIn, ParamValue *valueOut)
2125 {
2126     valueOut->EGLTimeKHRVal = valueIn;
2127 }
2128 
2129 template <>
2130 inline void SetParamVal<ParamType::TEGLenum>(EGLenum valueIn, ParamValue *valueOut)
2131 {
2132     valueOut->EGLenumVal = valueIn;
2133 }
2134 
2135 template <>
2136 inline void SetParamVal<ParamType::TEGLint>(EGLint valueIn, ParamValue *valueOut)
2137 {
2138     valueOut->EGLintVal = valueIn;
2139 }
2140 
2141 template <>
2142 inline void SetParamVal<ParamType::TEGLintConstPointer>(const EGLint *valueIn, ParamValue *valueOut)
2143 {
2144     valueOut->EGLintConstPointerVal = valueIn;
2145 }
2146 
2147 template <>
2148 inline void SetParamVal<ParamType::TEGLintPointer>(EGLint *valueIn, ParamValue *valueOut)
2149 {
2150     valueOut->EGLintPointerVal = valueIn;
2151 }
2152 
2153 template <>
2154 inline void SetParamVal<ParamType::TEGLnsecsANDROID>(EGLnsecsANDROID valueIn, ParamValue *valueOut)
2155 {
2156     valueOut->EGLnsecsANDROIDVal = valueIn;
2157 }
2158 
2159 template <>
2160 inline void SetParamVal<ParamType::TEGLnsecsANDROIDPointer>(EGLnsecsANDROID *valueIn,
2161                                                             ParamValue *valueOut)
2162 {
2163     valueOut->EGLnsecsANDROIDPointerVal = valueIn;
2164 }
2165 
2166 template <>
2167 inline void SetParamVal<ParamType::TEGLuint64KHR>(EGLuint64KHR valueIn, ParamValue *valueOut)
2168 {
2169     valueOut->EGLuint64KHRVal = valueIn;
2170 }
2171 
2172 template <>
2173 inline void SetParamVal<ParamType::TEGLuint64KHRPointer>(EGLuint64KHR *valueIn,
2174                                                          ParamValue *valueOut)
2175 {
2176     valueOut->EGLuint64KHRPointerVal = valueIn;
2177 }
2178 
2179 template <>
2180 inline void SetParamVal<ParamType::TFenceNVID>(gl::FenceNVID valueIn, ParamValue *valueOut)
2181 {
2182     valueOut->FenceNVIDVal = valueIn;
2183 }
2184 
2185 template <>
2186 inline void SetParamVal<ParamType::TFenceNVIDConstPointer>(const gl::FenceNVID *valueIn,
2187                                                            ParamValue *valueOut)
2188 {
2189     valueOut->FenceNVIDConstPointerVal = valueIn;
2190 }
2191 
2192 template <>
2193 inline void SetParamVal<ParamType::TFenceNVIDPointer>(gl::FenceNVID *valueIn, ParamValue *valueOut)
2194 {
2195     valueOut->FenceNVIDPointerVal = valueIn;
2196 }
2197 
2198 template <>
2199 inline void SetParamVal<ParamType::TFramebufferID>(gl::FramebufferID valueIn, ParamValue *valueOut)
2200 {
2201     valueOut->FramebufferIDVal = valueIn;
2202 }
2203 
2204 template <>
2205 inline void SetParamVal<ParamType::TFramebufferIDConstPointer>(const gl::FramebufferID *valueIn,
2206                                                                ParamValue *valueOut)
2207 {
2208     valueOut->FramebufferIDConstPointerVal = valueIn;
2209 }
2210 
2211 template <>
2212 inline void SetParamVal<ParamType::TFramebufferIDPointer>(gl::FramebufferID *valueIn,
2213                                                           ParamValue *valueOut)
2214 {
2215     valueOut->FramebufferIDPointerVal = valueIn;
2216 }
2217 
2218 template <>
2219 inline void SetParamVal<ParamType::TGLDEBUGPROC>(GLDEBUGPROC valueIn, ParamValue *valueOut)
2220 {
2221     valueOut->GLDEBUGPROCVal = valueIn;
2222 }
2223 
2224 template <>
2225 inline void SetParamVal<ParamType::TGLDEBUGPROCKHR>(GLDEBUGPROCKHR valueIn, ParamValue *valueOut)
2226 {
2227     valueOut->GLDEBUGPROCKHRVal = valueIn;
2228 }
2229 
2230 template <>
2231 inline void SetParamVal<ParamType::TGLbitfield>(GLbitfield valueIn, ParamValue *valueOut)
2232 {
2233     valueOut->GLbitfieldVal = valueIn;
2234 }
2235 
2236 template <>
2237 inline void SetParamVal<ParamType::TGLboolean>(GLboolean valueIn, ParamValue *valueOut)
2238 {
2239     valueOut->GLbooleanVal = valueIn;
2240 }
2241 
2242 template <>
2243 inline void SetParamVal<ParamType::TGLbooleanConstPointer>(const GLboolean *valueIn,
2244                                                            ParamValue *valueOut)
2245 {
2246     valueOut->GLbooleanConstPointerVal = valueIn;
2247 }
2248 
2249 template <>
2250 inline void SetParamVal<ParamType::TGLbooleanPointer>(GLboolean *valueIn, ParamValue *valueOut)
2251 {
2252     valueOut->GLbooleanPointerVal = valueIn;
2253 }
2254 
2255 template <>
2256 inline void SetParamVal<ParamType::TGLbyte>(GLbyte valueIn, ParamValue *valueOut)
2257 {
2258     valueOut->GLbyteVal = valueIn;
2259 }
2260 
2261 template <>
2262 inline void SetParamVal<ParamType::TGLbyteConstPointer>(const GLbyte *valueIn, ParamValue *valueOut)
2263 {
2264     valueOut->GLbyteConstPointerVal = valueIn;
2265 }
2266 
2267 template <>
2268 inline void SetParamVal<ParamType::TGLcharConstPointer>(const GLchar *valueIn, ParamValue *valueOut)
2269 {
2270     valueOut->GLcharConstPointerVal = valueIn;
2271 }
2272 
2273 template <>
2274 inline void SetParamVal<ParamType::TGLcharConstPointerPointer>(const GLchar *const *valueIn,
2275                                                                ParamValue *valueOut)
2276 {
2277     valueOut->GLcharConstPointerPointerVal = valueIn;
2278 }
2279 
2280 template <>
2281 inline void SetParamVal<ParamType::TGLcharPointer>(GLchar *valueIn, ParamValue *valueOut)
2282 {
2283     valueOut->GLcharPointerVal = valueIn;
2284 }
2285 
2286 template <>
2287 inline void SetParamVal<ParamType::TGLclampx>(GLclampx valueIn, ParamValue *valueOut)
2288 {
2289     valueOut->GLclampxVal = valueIn;
2290 }
2291 
2292 template <>
2293 inline void SetParamVal<ParamType::TGLdouble>(GLdouble valueIn, ParamValue *valueOut)
2294 {
2295     valueOut->GLdoubleVal = valueIn;
2296 }
2297 
2298 template <>
2299 inline void SetParamVal<ParamType::TGLdoubleConstPointer>(const GLdouble *valueIn,
2300                                                           ParamValue *valueOut)
2301 {
2302     valueOut->GLdoubleConstPointerVal = valueIn;
2303 }
2304 
2305 template <>
2306 inline void SetParamVal<ParamType::TGLdoublePointer>(GLdouble *valueIn, ParamValue *valueOut)
2307 {
2308     valueOut->GLdoublePointerVal = valueIn;
2309 }
2310 
2311 template <>
2312 inline void SetParamVal<ParamType::TGLeglClientBufferEXT>(GLeglClientBufferEXT valueIn,
2313                                                           ParamValue *valueOut)
2314 {
2315     valueOut->GLeglClientBufferEXTVal = valueIn;
2316 }
2317 
2318 template <>
2319 inline void SetParamVal<ParamType::TGLenum>(GLenum valueIn, ParamValue *valueOut)
2320 {
2321     valueOut->GLenumVal = valueIn;
2322 }
2323 
2324 template <>
2325 inline void SetParamVal<ParamType::TGLenumConstPointer>(const GLenum *valueIn, ParamValue *valueOut)
2326 {
2327     valueOut->GLenumConstPointerVal = valueIn;
2328 }
2329 
2330 template <>
2331 inline void SetParamVal<ParamType::TGLenumPointer>(GLenum *valueIn, ParamValue *valueOut)
2332 {
2333     valueOut->GLenumPointerVal = valueIn;
2334 }
2335 
2336 template <>
2337 inline void SetParamVal<ParamType::TGLfixed>(GLfixed valueIn, ParamValue *valueOut)
2338 {
2339     valueOut->GLfixedVal = valueIn;
2340 }
2341 
2342 template <>
2343 inline void SetParamVal<ParamType::TGLfixedConstPointer>(const GLfixed *valueIn,
2344                                                          ParamValue *valueOut)
2345 {
2346     valueOut->GLfixedConstPointerVal = valueIn;
2347 }
2348 
2349 template <>
2350 inline void SetParamVal<ParamType::TGLfixedPointer>(GLfixed *valueIn, ParamValue *valueOut)
2351 {
2352     valueOut->GLfixedPointerVal = valueIn;
2353 }
2354 
2355 template <>
2356 inline void SetParamVal<ParamType::TGLfloat>(GLfloat valueIn, ParamValue *valueOut)
2357 {
2358     valueOut->GLfloatVal = valueIn;
2359 }
2360 
2361 template <>
2362 inline void SetParamVal<ParamType::TGLfloatConstPointer>(const GLfloat *valueIn,
2363                                                          ParamValue *valueOut)
2364 {
2365     valueOut->GLfloatConstPointerVal = valueIn;
2366 }
2367 
2368 template <>
2369 inline void SetParamVal<ParamType::TGLfloatPointer>(GLfloat *valueIn, ParamValue *valueOut)
2370 {
2371     valueOut->GLfloatPointerVal = valueIn;
2372 }
2373 
2374 template <>
2375 inline void SetParamVal<ParamType::TGLint>(GLint valueIn, ParamValue *valueOut)
2376 {
2377     valueOut->GLintVal = valueIn;
2378 }
2379 
2380 template <>
2381 inline void SetParamVal<ParamType::TGLint64>(GLint64 valueIn, ParamValue *valueOut)
2382 {
2383     valueOut->GLint64Val = valueIn;
2384 }
2385 
2386 template <>
2387 inline void SetParamVal<ParamType::TGLint64Pointer>(GLint64 *valueIn, ParamValue *valueOut)
2388 {
2389     valueOut->GLint64PointerVal = valueIn;
2390 }
2391 
2392 template <>
2393 inline void SetParamVal<ParamType::TGLintConstPointer>(const GLint *valueIn, ParamValue *valueOut)
2394 {
2395     valueOut->GLintConstPointerVal = valueIn;
2396 }
2397 
2398 template <>
2399 inline void SetParamVal<ParamType::TGLintPointer>(GLint *valueIn, ParamValue *valueOut)
2400 {
2401     valueOut->GLintPointerVal = valueIn;
2402 }
2403 
2404 template <>
2405 inline void SetParamVal<ParamType::TGLintptr>(GLintptr valueIn, ParamValue *valueOut)
2406 {
2407     valueOut->GLintptrVal = valueIn;
2408 }
2409 
2410 template <>
2411 inline void SetParamVal<ParamType::TGLintptrConstPointer>(const GLintptr *valueIn,
2412                                                           ParamValue *valueOut)
2413 {
2414     valueOut->GLintptrConstPointerVal = valueIn;
2415 }
2416 
2417 template <>
2418 inline void SetParamVal<ParamType::TGLshort>(GLshort valueIn, ParamValue *valueOut)
2419 {
2420     valueOut->GLshortVal = valueIn;
2421 }
2422 
2423 template <>
2424 inline void SetParamVal<ParamType::TGLshortConstPointer>(const GLshort *valueIn,
2425                                                          ParamValue *valueOut)
2426 {
2427     valueOut->GLshortConstPointerVal = valueIn;
2428 }
2429 
2430 template <>
2431 inline void SetParamVal<ParamType::TGLsizei>(GLsizei valueIn, ParamValue *valueOut)
2432 {
2433     valueOut->GLsizeiVal = valueIn;
2434 }
2435 
2436 template <>
2437 inline void SetParamVal<ParamType::TGLsizeiConstPointer>(const GLsizei *valueIn,
2438                                                          ParamValue *valueOut)
2439 {
2440     valueOut->GLsizeiConstPointerVal = valueIn;
2441 }
2442 
2443 template <>
2444 inline void SetParamVal<ParamType::TGLsizeiPointer>(GLsizei *valueIn, ParamValue *valueOut)
2445 {
2446     valueOut->GLsizeiPointerVal = valueIn;
2447 }
2448 
2449 template <>
2450 inline void SetParamVal<ParamType::TGLsizeiptr>(GLsizeiptr valueIn, ParamValue *valueOut)
2451 {
2452     valueOut->GLsizeiptrVal = valueIn;
2453 }
2454 
2455 template <>
2456 inline void SetParamVal<ParamType::TGLsizeiptrConstPointer>(const GLsizeiptr *valueIn,
2457                                                             ParamValue *valueOut)
2458 {
2459     valueOut->GLsizeiptrConstPointerVal = valueIn;
2460 }
2461 
2462 template <>
2463 inline void SetParamVal<ParamType::TGLsync>(GLsync valueIn, ParamValue *valueOut)
2464 {
2465     valueOut->GLsyncVal = valueIn;
2466 }
2467 
2468 template <>
2469 inline void SetParamVal<ParamType::TGLubyte>(GLubyte valueIn, ParamValue *valueOut)
2470 {
2471     valueOut->GLubyteVal = valueIn;
2472 }
2473 
2474 template <>
2475 inline void SetParamVal<ParamType::TGLubyteConstPointer>(const GLubyte *valueIn,
2476                                                          ParamValue *valueOut)
2477 {
2478     valueOut->GLubyteConstPointerVal = valueIn;
2479 }
2480 
2481 template <>
2482 inline void SetParamVal<ParamType::TGLubytePointer>(GLubyte *valueIn, ParamValue *valueOut)
2483 {
2484     valueOut->GLubytePointerVal = valueIn;
2485 }
2486 
2487 template <>
2488 inline void SetParamVal<ParamType::TGLuint>(GLuint valueIn, ParamValue *valueOut)
2489 {
2490     valueOut->GLuintVal = valueIn;
2491 }
2492 
2493 template <>
2494 inline void SetParamVal<ParamType::TGLuint64>(GLuint64 valueIn, ParamValue *valueOut)
2495 {
2496     valueOut->GLuint64Val = valueIn;
2497 }
2498 
2499 template <>
2500 inline void SetParamVal<ParamType::TGLuint64ConstPointer>(const GLuint64 *valueIn,
2501                                                           ParamValue *valueOut)
2502 {
2503     valueOut->GLuint64ConstPointerVal = valueIn;
2504 }
2505 
2506 template <>
2507 inline void SetParamVal<ParamType::TGLuint64Pointer>(GLuint64 *valueIn, ParamValue *valueOut)
2508 {
2509     valueOut->GLuint64PointerVal = valueIn;
2510 }
2511 
2512 template <>
2513 inline void SetParamVal<ParamType::TGLuintConstPointer>(const GLuint *valueIn, ParamValue *valueOut)
2514 {
2515     valueOut->GLuintConstPointerVal = valueIn;
2516 }
2517 
2518 template <>
2519 inline void SetParamVal<ParamType::TGLuintPointer>(GLuint *valueIn, ParamValue *valueOut)
2520 {
2521     valueOut->GLuintPointerVal = valueIn;
2522 }
2523 
2524 template <>
2525 inline void SetParamVal<ParamType::TGLushort>(GLushort valueIn, ParamValue *valueOut)
2526 {
2527     valueOut->GLushortVal = valueIn;
2528 }
2529 
2530 template <>
2531 inline void SetParamVal<ParamType::TGLushortConstPointer>(const GLushort *valueIn,
2532                                                           ParamValue *valueOut)
2533 {
2534     valueOut->GLushortConstPointerVal = valueIn;
2535 }
2536 
2537 template <>
2538 inline void SetParamVal<ParamType::TGLushortPointer>(GLushort *valueIn, ParamValue *valueOut)
2539 {
2540     valueOut->GLushortPointerVal = valueIn;
2541 }
2542 
2543 template <>
2544 inline void SetParamVal<ParamType::TGraphicsResetStatus>(gl::GraphicsResetStatus valueIn,
2545                                                          ParamValue *valueOut)
2546 {
2547     valueOut->GraphicsResetStatusVal = valueIn;
2548 }
2549 
2550 template <>
2551 inline void SetParamVal<ParamType::THandleType>(gl::HandleType valueIn, ParamValue *valueOut)
2552 {
2553     valueOut->HandleTypeVal = valueIn;
2554 }
2555 
2556 template <>
2557 inline void SetParamVal<ParamType::TImageID>(egl::ImageID valueIn, ParamValue *valueOut)
2558 {
2559     valueOut->ImageIDVal = valueIn;
2560 }
2561 
2562 template <>
2563 inline void SetParamVal<ParamType::TLightParameter>(gl::LightParameter valueIn,
2564                                                     ParamValue *valueOut)
2565 {
2566     valueOut->LightParameterVal = valueIn;
2567 }
2568 
2569 template <>
2570 inline void SetParamVal<ParamType::TLogicalOperation>(gl::LogicalOperation valueIn,
2571                                                       ParamValue *valueOut)
2572 {
2573     valueOut->LogicalOperationVal = valueIn;
2574 }
2575 
2576 template <>
2577 inline void SetParamVal<ParamType::TMaterialParameter>(gl::MaterialParameter valueIn,
2578                                                        ParamValue *valueOut)
2579 {
2580     valueOut->MaterialParameterVal = valueIn;
2581 }
2582 
2583 template <>
2584 inline void SetParamVal<ParamType::TMatrixType>(gl::MatrixType valueIn, ParamValue *valueOut)
2585 {
2586     valueOut->MatrixTypeVal = valueIn;
2587 }
2588 
2589 template <>
2590 inline void SetParamVal<ParamType::TMemoryObjectID>(gl::MemoryObjectID valueIn,
2591                                                     ParamValue *valueOut)
2592 {
2593     valueOut->MemoryObjectIDVal = valueIn;
2594 }
2595 
2596 template <>
2597 inline void SetParamVal<ParamType::TMemoryObjectIDConstPointer>(const gl::MemoryObjectID *valueIn,
2598                                                                 ParamValue *valueOut)
2599 {
2600     valueOut->MemoryObjectIDConstPointerVal = valueIn;
2601 }
2602 
2603 template <>
2604 inline void SetParamVal<ParamType::TMemoryObjectIDPointer>(gl::MemoryObjectID *valueIn,
2605                                                            ParamValue *valueOut)
2606 {
2607     valueOut->MemoryObjectIDPointerVal = valueIn;
2608 }
2609 
2610 template <>
2611 inline void SetParamVal<ParamType::TObjectType>(egl::ObjectType valueIn, ParamValue *valueOut)
2612 {
2613     valueOut->ObjectTypeVal = valueIn;
2614 }
2615 
2616 template <>
2617 inline void SetParamVal<ParamType::TPointParameter>(gl::PointParameter valueIn,
2618                                                     ParamValue *valueOut)
2619 {
2620     valueOut->PointParameterVal = valueIn;
2621 }
2622 
2623 template <>
2624 inline void SetParamVal<ParamType::TPolygonMode>(gl::PolygonMode valueIn, ParamValue *valueOut)
2625 {
2626     valueOut->PolygonModeVal = valueIn;
2627 }
2628 
2629 template <>
2630 inline void SetParamVal<ParamType::TPrimitiveMode>(gl::PrimitiveMode valueIn, ParamValue *valueOut)
2631 {
2632     valueOut->PrimitiveModeVal = valueIn;
2633 }
2634 
2635 template <>
2636 inline void SetParamVal<ParamType::TProgramPipelineID>(gl::ProgramPipelineID valueIn,
2637                                                        ParamValue *valueOut)
2638 {
2639     valueOut->ProgramPipelineIDVal = valueIn;
2640 }
2641 
2642 template <>
2643 inline void SetParamVal<ParamType::TProgramPipelineIDConstPointer>(
2644     const gl::ProgramPipelineID *valueIn,
2645     ParamValue *valueOut)
2646 {
2647     valueOut->ProgramPipelineIDConstPointerVal = valueIn;
2648 }
2649 
2650 template <>
2651 inline void SetParamVal<ParamType::TProgramPipelineIDPointer>(gl::ProgramPipelineID *valueIn,
2652                                                               ParamValue *valueOut)
2653 {
2654     valueOut->ProgramPipelineIDPointerVal = valueIn;
2655 }
2656 
2657 template <>
2658 inline void SetParamVal<ParamType::TProvokingVertexConvention>(
2659     gl::ProvokingVertexConvention valueIn,
2660     ParamValue *valueOut)
2661 {
2662     valueOut->ProvokingVertexConventionVal = valueIn;
2663 }
2664 
2665 template <>
2666 inline void SetParamVal<ParamType::TQueryID>(gl::QueryID valueIn, ParamValue *valueOut)
2667 {
2668     valueOut->QueryIDVal = valueIn;
2669 }
2670 
2671 template <>
2672 inline void SetParamVal<ParamType::TQueryIDConstPointer>(const gl::QueryID *valueIn,
2673                                                          ParamValue *valueOut)
2674 {
2675     valueOut->QueryIDConstPointerVal = valueIn;
2676 }
2677 
2678 template <>
2679 inline void SetParamVal<ParamType::TQueryIDPointer>(gl::QueryID *valueIn, ParamValue *valueOut)
2680 {
2681     valueOut->QueryIDPointerVal = valueIn;
2682 }
2683 
2684 template <>
2685 inline void SetParamVal<ParamType::TQueryType>(gl::QueryType valueIn, ParamValue *valueOut)
2686 {
2687     valueOut->QueryTypeVal = valueIn;
2688 }
2689 
2690 template <>
2691 inline void SetParamVal<ParamType::TRenderbufferID>(gl::RenderbufferID valueIn,
2692                                                     ParamValue *valueOut)
2693 {
2694     valueOut->RenderbufferIDVal = valueIn;
2695 }
2696 
2697 template <>
2698 inline void SetParamVal<ParamType::TRenderbufferIDConstPointer>(const gl::RenderbufferID *valueIn,
2699                                                                 ParamValue *valueOut)
2700 {
2701     valueOut->RenderbufferIDConstPointerVal = valueIn;
2702 }
2703 
2704 template <>
2705 inline void SetParamVal<ParamType::TRenderbufferIDPointer>(gl::RenderbufferID *valueIn,
2706                                                            ParamValue *valueOut)
2707 {
2708     valueOut->RenderbufferIDPointerVal = valueIn;
2709 }
2710 
2711 template <>
2712 inline void SetParamVal<ParamType::TSamplerID>(gl::SamplerID valueIn, ParamValue *valueOut)
2713 {
2714     valueOut->SamplerIDVal = valueIn;
2715 }
2716 
2717 template <>
2718 inline void SetParamVal<ParamType::TSamplerIDConstPointer>(const gl::SamplerID *valueIn,
2719                                                            ParamValue *valueOut)
2720 {
2721     valueOut->SamplerIDConstPointerVal = valueIn;
2722 }
2723 
2724 template <>
2725 inline void SetParamVal<ParamType::TSamplerIDPointer>(gl::SamplerID *valueIn, ParamValue *valueOut)
2726 {
2727     valueOut->SamplerIDPointerVal = valueIn;
2728 }
2729 
2730 template <>
2731 inline void SetParamVal<ParamType::TSemaphoreID>(gl::SemaphoreID valueIn, ParamValue *valueOut)
2732 {
2733     valueOut->SemaphoreIDVal = valueIn;
2734 }
2735 
2736 template <>
2737 inline void SetParamVal<ParamType::TSemaphoreIDConstPointer>(const gl::SemaphoreID *valueIn,
2738                                                              ParamValue *valueOut)
2739 {
2740     valueOut->SemaphoreIDConstPointerVal = valueIn;
2741 }
2742 
2743 template <>
2744 inline void SetParamVal<ParamType::TSemaphoreIDPointer>(gl::SemaphoreID *valueIn,
2745                                                         ParamValue *valueOut)
2746 {
2747     valueOut->SemaphoreIDPointerVal = valueIn;
2748 }
2749 
2750 template <>
2751 inline void SetParamVal<ParamType::TShaderProgramID>(gl::ShaderProgramID valueIn,
2752                                                      ParamValue *valueOut)
2753 {
2754     valueOut->ShaderProgramIDVal = valueIn;
2755 }
2756 
2757 template <>
2758 inline void SetParamVal<ParamType::TShaderProgramIDConstPointer>(const gl::ShaderProgramID *valueIn,
2759                                                                  ParamValue *valueOut)
2760 {
2761     valueOut->ShaderProgramIDConstPointerVal = valueIn;
2762 }
2763 
2764 template <>
2765 inline void SetParamVal<ParamType::TShaderProgramIDPointer>(gl::ShaderProgramID *valueIn,
2766                                                             ParamValue *valueOut)
2767 {
2768     valueOut->ShaderProgramIDPointerVal = valueIn;
2769 }
2770 
2771 template <>
2772 inline void SetParamVal<ParamType::TShaderType>(gl::ShaderType valueIn, ParamValue *valueOut)
2773 {
2774     valueOut->ShaderTypeVal = valueIn;
2775 }
2776 
2777 template <>
2778 inline void SetParamVal<ParamType::TShadingModel>(gl::ShadingModel valueIn, ParamValue *valueOut)
2779 {
2780     valueOut->ShadingModelVal = valueIn;
2781 }
2782 
2783 template <>
2784 inline void SetParamVal<ParamType::TSurfaceID>(egl::SurfaceID valueIn, ParamValue *valueOut)
2785 {
2786     valueOut->SurfaceIDVal = valueIn;
2787 }
2788 
2789 template <>
2790 inline void SetParamVal<ParamType::TSyncID>(gl::SyncID valueIn, ParamValue *valueOut)
2791 {
2792     valueOut->SyncIDVal = valueIn;
2793 }
2794 
2795 template <>
2796 inline void SetParamVal<ParamType::TTextureEnvParameter>(gl::TextureEnvParameter valueIn,
2797                                                          ParamValue *valueOut)
2798 {
2799     valueOut->TextureEnvParameterVal = valueIn;
2800 }
2801 
2802 template <>
2803 inline void SetParamVal<ParamType::TTextureEnvTarget>(gl::TextureEnvTarget valueIn,
2804                                                       ParamValue *valueOut)
2805 {
2806     valueOut->TextureEnvTargetVal = valueIn;
2807 }
2808 
2809 template <>
2810 inline void SetParamVal<ParamType::TTextureID>(gl::TextureID valueIn, ParamValue *valueOut)
2811 {
2812     valueOut->TextureIDVal = valueIn;
2813 }
2814 
2815 template <>
2816 inline void SetParamVal<ParamType::TTextureIDConstPointer>(const gl::TextureID *valueIn,
2817                                                            ParamValue *valueOut)
2818 {
2819     valueOut->TextureIDConstPointerVal = valueIn;
2820 }
2821 
2822 template <>
2823 inline void SetParamVal<ParamType::TTextureIDPointer>(gl::TextureID *valueIn, ParamValue *valueOut)
2824 {
2825     valueOut->TextureIDPointerVal = valueIn;
2826 }
2827 
2828 template <>
2829 inline void SetParamVal<ParamType::TTextureTarget>(gl::TextureTarget valueIn, ParamValue *valueOut)
2830 {
2831     valueOut->TextureTargetVal = valueIn;
2832 }
2833 
2834 template <>
2835 inline void SetParamVal<ParamType::TTextureType>(gl::TextureType valueIn, ParamValue *valueOut)
2836 {
2837     valueOut->TextureTypeVal = valueIn;
2838 }
2839 
2840 template <>
2841 inline void SetParamVal<ParamType::TTimestamp>(egl::Timestamp valueIn, ParamValue *valueOut)
2842 {
2843     valueOut->TimestampVal = valueIn;
2844 }
2845 
2846 template <>
2847 inline void SetParamVal<ParamType::TTransformFeedbackID>(gl::TransformFeedbackID valueIn,
2848                                                          ParamValue *valueOut)
2849 {
2850     valueOut->TransformFeedbackIDVal = valueIn;
2851 }
2852 
2853 template <>
2854 inline void SetParamVal<ParamType::TTransformFeedbackIDConstPointer>(
2855     const gl::TransformFeedbackID *valueIn,
2856     ParamValue *valueOut)
2857 {
2858     valueOut->TransformFeedbackIDConstPointerVal = valueIn;
2859 }
2860 
2861 template <>
2862 inline void SetParamVal<ParamType::TTransformFeedbackIDPointer>(gl::TransformFeedbackID *valueIn,
2863                                                                 ParamValue *valueOut)
2864 {
2865     valueOut->TransformFeedbackIDPointerVal = valueIn;
2866 }
2867 
2868 template <>
2869 inline void SetParamVal<ParamType::TUniformBlockIndex>(gl::UniformBlockIndex valueIn,
2870                                                        ParamValue *valueOut)
2871 {
2872     valueOut->UniformBlockIndexVal = valueIn;
2873 }
2874 
2875 template <>
2876 inline void SetParamVal<ParamType::TUniformLocation>(gl::UniformLocation valueIn,
2877                                                      ParamValue *valueOut)
2878 {
2879     valueOut->UniformLocationVal = valueIn;
2880 }
2881 
2882 template <>
2883 inline void SetParamVal<ParamType::TVertexArrayID>(gl::VertexArrayID valueIn, ParamValue *valueOut)
2884 {
2885     valueOut->VertexArrayIDVal = valueIn;
2886 }
2887 
2888 template <>
2889 inline void SetParamVal<ParamType::TVertexArrayIDConstPointer>(const gl::VertexArrayID *valueIn,
2890                                                                ParamValue *valueOut)
2891 {
2892     valueOut->VertexArrayIDConstPointerVal = valueIn;
2893 }
2894 
2895 template <>
2896 inline void SetParamVal<ParamType::TVertexArrayIDPointer>(gl::VertexArrayID *valueIn,
2897                                                           ParamValue *valueOut)
2898 {
2899     valueOut->VertexArrayIDPointerVal = valueIn;
2900 }
2901 
2902 template <>
2903 inline void SetParamVal<ParamType::TVertexAttribType>(gl::VertexAttribType valueIn,
2904                                                       ParamValue *valueOut)
2905 {
2906     valueOut->VertexAttribTypeVal = valueIn;
2907 }
2908 
2909 template <>
2910 inline void SetParamVal<ParamType::TcharConstPointer>(const char *valueIn, ParamValue *valueOut)
2911 {
2912     valueOut->charConstPointerVal = valueIn;
2913 }
2914 
2915 template <>
2916 inline void SetParamVal<ParamType::Tegl_ConfigPointer>(egl::Config *valueIn, ParamValue *valueOut)
2917 {
2918     valueOut->egl_ConfigPointerVal = valueIn;
2919 }
2920 
2921 template <>
2922 inline void SetParamVal<ParamType::Tegl_DevicePointer>(egl::Device *valueIn, ParamValue *valueOut)
2923 {
2924     valueOut->egl_DevicePointerVal = valueIn;
2925 }
2926 
2927 template <>
2928 inline void SetParamVal<ParamType::Tegl_DisplayPointer>(egl::Display *valueIn, ParamValue *valueOut)
2929 {
2930     valueOut->egl_DisplayPointerVal = valueIn;
2931 }
2932 
2933 template <>
2934 inline void SetParamVal<ParamType::Tegl_StreamPointer>(egl::Stream *valueIn, ParamValue *valueOut)
2935 {
2936     valueOut->egl_StreamPointerVal = valueIn;
2937 }
2938 
2939 template <>
2940 inline void SetParamVal<ParamType::Tegl_SyncID>(egl::SyncID valueIn, ParamValue *valueOut)
2941 {
2942     valueOut->egl_SyncIDVal = valueIn;
2943 }
2944 
2945 template <>
2946 inline void SetParamVal<ParamType::TvoidConstPointer>(const void *valueIn, ParamValue *valueOut)
2947 {
2948     valueOut->voidConstPointerVal = valueIn;
2949 }
2950 
2951 template <>
2952 inline void SetParamVal<ParamType::TvoidConstPointerPointer>(const void *const *valueIn,
2953                                                              ParamValue *valueOut)
2954 {
2955     valueOut->voidConstPointerPointerVal = valueIn;
2956 }
2957 
2958 template <>
2959 inline void SetParamVal<ParamType::TvoidPointer>(void *valueIn, ParamValue *valueOut)
2960 {
2961     valueOut->voidPointerVal = valueIn;
2962 }
2963 
2964 template <>
2965 inline void SetParamVal<ParamType::TvoidPointerPointer>(void **valueIn, ParamValue *valueOut)
2966 {
2967     valueOut->voidPointerPointerVal = valueIn;
2968 }
2969 
2970 template <ParamType PType, typename T>
SetParamVal(T valueIn,ParamValue * valueOut)2971 void SetParamVal(T valueIn, ParamValue *valueOut)
2972 {
2973     UNREACHABLE();
2974 }
2975 
2976 template <typename T>
InitParamValue(ParamType paramType,T valueIn,ParamValue * valueOut)2977 void InitParamValue(ParamType paramType, T valueIn, ParamValue *valueOut)
2978 {
2979     switch (paramType)
2980     {
2981         case ParamType::TAHardwareBufferConstPointer:
2982             SetParamVal<ParamType::TAHardwareBufferConstPointer>(valueIn, valueOut);
2983             break;
2984         case ParamType::TAlphaTestFunc:
2985             SetParamVal<ParamType::TAlphaTestFunc>(valueIn, valueOut);
2986             break;
2987         case ParamType::TBufferBinding:
2988             SetParamVal<ParamType::TBufferBinding>(valueIn, valueOut);
2989             break;
2990         case ParamType::TBufferID:
2991             SetParamVal<ParamType::TBufferID>(valueIn, valueOut);
2992             break;
2993         case ParamType::TBufferIDConstPointer:
2994             SetParamVal<ParamType::TBufferIDConstPointer>(valueIn, valueOut);
2995             break;
2996         case ParamType::TBufferIDPointer:
2997             SetParamVal<ParamType::TBufferIDPointer>(valueIn, valueOut);
2998             break;
2999         case ParamType::TBufferUsage:
3000             SetParamVal<ParamType::TBufferUsage>(valueIn, valueOut);
3001             break;
3002         case ParamType::TClientVertexArrayType:
3003             SetParamVal<ParamType::TClientVertexArrayType>(valueIn, valueOut);
3004             break;
3005         case ParamType::TClipDepthMode:
3006             SetParamVal<ParamType::TClipDepthMode>(valueIn, valueOut);
3007             break;
3008         case ParamType::TClipOrigin:
3009             SetParamVal<ParamType::TClipOrigin>(valueIn, valueOut);
3010             break;
3011         case ParamType::TCompositorTiming:
3012             SetParamVal<ParamType::TCompositorTiming>(valueIn, valueOut);
3013             break;
3014         case ParamType::TContextID:
3015             SetParamVal<ParamType::TContextID>(valueIn, valueOut);
3016             break;
3017         case ParamType::TCullFaceMode:
3018             SetParamVal<ParamType::TCullFaceMode>(valueIn, valueOut);
3019             break;
3020         case ParamType::TDrawElementsType:
3021             SetParamVal<ParamType::TDrawElementsType>(valueIn, valueOut);
3022             break;
3023         case ParamType::TEGLAttribConstPointer:
3024             SetParamVal<ParamType::TEGLAttribConstPointer>(valueIn, valueOut);
3025             break;
3026         case ParamType::TEGLAttribKHRPointer:
3027             SetParamVal<ParamType::TEGLAttribKHRPointer>(valueIn, valueOut);
3028             break;
3029         case ParamType::TEGLAttribPointer:
3030             SetParamVal<ParamType::TEGLAttribPointer>(valueIn, valueOut);
3031             break;
3032         case ParamType::TEGLBoolean:
3033             SetParamVal<ParamType::TEGLBoolean>(valueIn, valueOut);
3034             break;
3035         case ParamType::TEGLBooleanPointer:
3036             SetParamVal<ParamType::TEGLBooleanPointer>(valueIn, valueOut);
3037             break;
3038         case ParamType::TEGLClientBuffer:
3039             SetParamVal<ParamType::TEGLClientBuffer>(valueIn, valueOut);
3040             break;
3041         case ParamType::TEGLConfigPointer:
3042             SetParamVal<ParamType::TEGLConfigPointer>(valueIn, valueOut);
3043             break;
3044         case ParamType::TEGLContext:
3045             SetParamVal<ParamType::TEGLContext>(valueIn, valueOut);
3046             break;
3047         case ParamType::TEGLDEBUGPROCKHR:
3048             SetParamVal<ParamType::TEGLDEBUGPROCKHR>(valueIn, valueOut);
3049             break;
3050         case ParamType::TEGLDeviceEXT:
3051             SetParamVal<ParamType::TEGLDeviceEXT>(valueIn, valueOut);
3052             break;
3053         case ParamType::TEGLDisplay:
3054             SetParamVal<ParamType::TEGLDisplay>(valueIn, valueOut);
3055             break;
3056         case ParamType::TEGLFrameTokenANGLE:
3057             SetParamVal<ParamType::TEGLFrameTokenANGLE>(valueIn, valueOut);
3058             break;
3059         case ParamType::TEGLGetBlobFuncANDROID:
3060             SetParamVal<ParamType::TEGLGetBlobFuncANDROID>(valueIn, valueOut);
3061             break;
3062         case ParamType::TEGLImage:
3063             SetParamVal<ParamType::TEGLImage>(valueIn, valueOut);
3064             break;
3065         case ParamType::TEGLImageKHR:
3066             SetParamVal<ParamType::TEGLImageKHR>(valueIn, valueOut);
3067             break;
3068         case ParamType::TEGLLabelKHR:
3069             SetParamVal<ParamType::TEGLLabelKHR>(valueIn, valueOut);
3070             break;
3071         case ParamType::TEGLNativeDisplayType:
3072             SetParamVal<ParamType::TEGLNativeDisplayType>(valueIn, valueOut);
3073             break;
3074         case ParamType::TEGLNativePixmapType:
3075             SetParamVal<ParamType::TEGLNativePixmapType>(valueIn, valueOut);
3076             break;
3077         case ParamType::TEGLNativeWindowType:
3078             SetParamVal<ParamType::TEGLNativeWindowType>(valueIn, valueOut);
3079             break;
3080         case ParamType::TEGLObjectKHR:
3081             SetParamVal<ParamType::TEGLObjectKHR>(valueIn, valueOut);
3082             break;
3083         case ParamType::TEGLSetBlobFuncANDROID:
3084             SetParamVal<ParamType::TEGLSetBlobFuncANDROID>(valueIn, valueOut);
3085             break;
3086         case ParamType::TEGLStreamKHR:
3087             SetParamVal<ParamType::TEGLStreamKHR>(valueIn, valueOut);
3088             break;
3089         case ParamType::TEGLSurface:
3090             SetParamVal<ParamType::TEGLSurface>(valueIn, valueOut);
3091             break;
3092         case ParamType::TEGLSync:
3093             SetParamVal<ParamType::TEGLSync>(valueIn, valueOut);
3094             break;
3095         case ParamType::TEGLSyncKHR:
3096             SetParamVal<ParamType::TEGLSyncKHR>(valueIn, valueOut);
3097             break;
3098         case ParamType::TEGLTime:
3099             SetParamVal<ParamType::TEGLTime>(valueIn, valueOut);
3100             break;
3101         case ParamType::TEGLTimeKHR:
3102             SetParamVal<ParamType::TEGLTimeKHR>(valueIn, valueOut);
3103             break;
3104         case ParamType::TEGLenum:
3105             SetParamVal<ParamType::TEGLenum>(valueIn, valueOut);
3106             break;
3107         case ParamType::TEGLint:
3108             SetParamVal<ParamType::TEGLint>(valueIn, valueOut);
3109             break;
3110         case ParamType::TEGLintConstPointer:
3111             SetParamVal<ParamType::TEGLintConstPointer>(valueIn, valueOut);
3112             break;
3113         case ParamType::TEGLintPointer:
3114             SetParamVal<ParamType::TEGLintPointer>(valueIn, valueOut);
3115             break;
3116         case ParamType::TEGLnsecsANDROID:
3117             SetParamVal<ParamType::TEGLnsecsANDROID>(valueIn, valueOut);
3118             break;
3119         case ParamType::TEGLnsecsANDROIDPointer:
3120             SetParamVal<ParamType::TEGLnsecsANDROIDPointer>(valueIn, valueOut);
3121             break;
3122         case ParamType::TEGLuint64KHR:
3123             SetParamVal<ParamType::TEGLuint64KHR>(valueIn, valueOut);
3124             break;
3125         case ParamType::TEGLuint64KHRPointer:
3126             SetParamVal<ParamType::TEGLuint64KHRPointer>(valueIn, valueOut);
3127             break;
3128         case ParamType::TFenceNVID:
3129             SetParamVal<ParamType::TFenceNVID>(valueIn, valueOut);
3130             break;
3131         case ParamType::TFenceNVIDConstPointer:
3132             SetParamVal<ParamType::TFenceNVIDConstPointer>(valueIn, valueOut);
3133             break;
3134         case ParamType::TFenceNVIDPointer:
3135             SetParamVal<ParamType::TFenceNVIDPointer>(valueIn, valueOut);
3136             break;
3137         case ParamType::TFramebufferID:
3138             SetParamVal<ParamType::TFramebufferID>(valueIn, valueOut);
3139             break;
3140         case ParamType::TFramebufferIDConstPointer:
3141             SetParamVal<ParamType::TFramebufferIDConstPointer>(valueIn, valueOut);
3142             break;
3143         case ParamType::TFramebufferIDPointer:
3144             SetParamVal<ParamType::TFramebufferIDPointer>(valueIn, valueOut);
3145             break;
3146         case ParamType::TGLDEBUGPROC:
3147             SetParamVal<ParamType::TGLDEBUGPROC>(valueIn, valueOut);
3148             break;
3149         case ParamType::TGLDEBUGPROCKHR:
3150             SetParamVal<ParamType::TGLDEBUGPROCKHR>(valueIn, valueOut);
3151             break;
3152         case ParamType::TGLbitfield:
3153             SetParamVal<ParamType::TGLbitfield>(valueIn, valueOut);
3154             break;
3155         case ParamType::TGLboolean:
3156             SetParamVal<ParamType::TGLboolean>(valueIn, valueOut);
3157             break;
3158         case ParamType::TGLbooleanConstPointer:
3159             SetParamVal<ParamType::TGLbooleanConstPointer>(valueIn, valueOut);
3160             break;
3161         case ParamType::TGLbooleanPointer:
3162             SetParamVal<ParamType::TGLbooleanPointer>(valueIn, valueOut);
3163             break;
3164         case ParamType::TGLbyte:
3165             SetParamVal<ParamType::TGLbyte>(valueIn, valueOut);
3166             break;
3167         case ParamType::TGLbyteConstPointer:
3168             SetParamVal<ParamType::TGLbyteConstPointer>(valueIn, valueOut);
3169             break;
3170         case ParamType::TGLcharConstPointer:
3171             SetParamVal<ParamType::TGLcharConstPointer>(valueIn, valueOut);
3172             break;
3173         case ParamType::TGLcharConstPointerPointer:
3174             SetParamVal<ParamType::TGLcharConstPointerPointer>(valueIn, valueOut);
3175             break;
3176         case ParamType::TGLcharPointer:
3177             SetParamVal<ParamType::TGLcharPointer>(valueIn, valueOut);
3178             break;
3179         case ParamType::TGLclampx:
3180             SetParamVal<ParamType::TGLclampx>(valueIn, valueOut);
3181             break;
3182         case ParamType::TGLdouble:
3183             SetParamVal<ParamType::TGLdouble>(valueIn, valueOut);
3184             break;
3185         case ParamType::TGLdoubleConstPointer:
3186             SetParamVal<ParamType::TGLdoubleConstPointer>(valueIn, valueOut);
3187             break;
3188         case ParamType::TGLdoublePointer:
3189             SetParamVal<ParamType::TGLdoublePointer>(valueIn, valueOut);
3190             break;
3191         case ParamType::TGLeglClientBufferEXT:
3192             SetParamVal<ParamType::TGLeglClientBufferEXT>(valueIn, valueOut);
3193             break;
3194         case ParamType::TGLenum:
3195             SetParamVal<ParamType::TGLenum>(valueIn, valueOut);
3196             break;
3197         case ParamType::TGLenumConstPointer:
3198             SetParamVal<ParamType::TGLenumConstPointer>(valueIn, valueOut);
3199             break;
3200         case ParamType::TGLenumPointer:
3201             SetParamVal<ParamType::TGLenumPointer>(valueIn, valueOut);
3202             break;
3203         case ParamType::TGLfixed:
3204             SetParamVal<ParamType::TGLfixed>(valueIn, valueOut);
3205             break;
3206         case ParamType::TGLfixedConstPointer:
3207             SetParamVal<ParamType::TGLfixedConstPointer>(valueIn, valueOut);
3208             break;
3209         case ParamType::TGLfixedPointer:
3210             SetParamVal<ParamType::TGLfixedPointer>(valueIn, valueOut);
3211             break;
3212         case ParamType::TGLfloat:
3213             SetParamVal<ParamType::TGLfloat>(valueIn, valueOut);
3214             break;
3215         case ParamType::TGLfloatConstPointer:
3216             SetParamVal<ParamType::TGLfloatConstPointer>(valueIn, valueOut);
3217             break;
3218         case ParamType::TGLfloatPointer:
3219             SetParamVal<ParamType::TGLfloatPointer>(valueIn, valueOut);
3220             break;
3221         case ParamType::TGLint:
3222             SetParamVal<ParamType::TGLint>(valueIn, valueOut);
3223             break;
3224         case ParamType::TGLint64:
3225             SetParamVal<ParamType::TGLint64>(valueIn, valueOut);
3226             break;
3227         case ParamType::TGLint64Pointer:
3228             SetParamVal<ParamType::TGLint64Pointer>(valueIn, valueOut);
3229             break;
3230         case ParamType::TGLintConstPointer:
3231             SetParamVal<ParamType::TGLintConstPointer>(valueIn, valueOut);
3232             break;
3233         case ParamType::TGLintPointer:
3234             SetParamVal<ParamType::TGLintPointer>(valueIn, valueOut);
3235             break;
3236         case ParamType::TGLintptr:
3237             SetParamVal<ParamType::TGLintptr>(valueIn, valueOut);
3238             break;
3239         case ParamType::TGLintptrConstPointer:
3240             SetParamVal<ParamType::TGLintptrConstPointer>(valueIn, valueOut);
3241             break;
3242         case ParamType::TGLshort:
3243             SetParamVal<ParamType::TGLshort>(valueIn, valueOut);
3244             break;
3245         case ParamType::TGLshortConstPointer:
3246             SetParamVal<ParamType::TGLshortConstPointer>(valueIn, valueOut);
3247             break;
3248         case ParamType::TGLsizei:
3249             SetParamVal<ParamType::TGLsizei>(valueIn, valueOut);
3250             break;
3251         case ParamType::TGLsizeiConstPointer:
3252             SetParamVal<ParamType::TGLsizeiConstPointer>(valueIn, valueOut);
3253             break;
3254         case ParamType::TGLsizeiPointer:
3255             SetParamVal<ParamType::TGLsizeiPointer>(valueIn, valueOut);
3256             break;
3257         case ParamType::TGLsizeiptr:
3258             SetParamVal<ParamType::TGLsizeiptr>(valueIn, valueOut);
3259             break;
3260         case ParamType::TGLsizeiptrConstPointer:
3261             SetParamVal<ParamType::TGLsizeiptrConstPointer>(valueIn, valueOut);
3262             break;
3263         case ParamType::TGLsync:
3264             SetParamVal<ParamType::TGLsync>(valueIn, valueOut);
3265             break;
3266         case ParamType::TGLubyte:
3267             SetParamVal<ParamType::TGLubyte>(valueIn, valueOut);
3268             break;
3269         case ParamType::TGLubyteConstPointer:
3270             SetParamVal<ParamType::TGLubyteConstPointer>(valueIn, valueOut);
3271             break;
3272         case ParamType::TGLubytePointer:
3273             SetParamVal<ParamType::TGLubytePointer>(valueIn, valueOut);
3274             break;
3275         case ParamType::TGLuint:
3276             SetParamVal<ParamType::TGLuint>(valueIn, valueOut);
3277             break;
3278         case ParamType::TGLuint64:
3279             SetParamVal<ParamType::TGLuint64>(valueIn, valueOut);
3280             break;
3281         case ParamType::TGLuint64ConstPointer:
3282             SetParamVal<ParamType::TGLuint64ConstPointer>(valueIn, valueOut);
3283             break;
3284         case ParamType::TGLuint64Pointer:
3285             SetParamVal<ParamType::TGLuint64Pointer>(valueIn, valueOut);
3286             break;
3287         case ParamType::TGLuintConstPointer:
3288             SetParamVal<ParamType::TGLuintConstPointer>(valueIn, valueOut);
3289             break;
3290         case ParamType::TGLuintPointer:
3291             SetParamVal<ParamType::TGLuintPointer>(valueIn, valueOut);
3292             break;
3293         case ParamType::TGLushort:
3294             SetParamVal<ParamType::TGLushort>(valueIn, valueOut);
3295             break;
3296         case ParamType::TGLushortConstPointer:
3297             SetParamVal<ParamType::TGLushortConstPointer>(valueIn, valueOut);
3298             break;
3299         case ParamType::TGLushortPointer:
3300             SetParamVal<ParamType::TGLushortPointer>(valueIn, valueOut);
3301             break;
3302         case ParamType::TGraphicsResetStatus:
3303             SetParamVal<ParamType::TGraphicsResetStatus>(valueIn, valueOut);
3304             break;
3305         case ParamType::THandleType:
3306             SetParamVal<ParamType::THandleType>(valueIn, valueOut);
3307             break;
3308         case ParamType::TImageID:
3309             SetParamVal<ParamType::TImageID>(valueIn, valueOut);
3310             break;
3311         case ParamType::TLightParameter:
3312             SetParamVal<ParamType::TLightParameter>(valueIn, valueOut);
3313             break;
3314         case ParamType::TLogicalOperation:
3315             SetParamVal<ParamType::TLogicalOperation>(valueIn, valueOut);
3316             break;
3317         case ParamType::TMaterialParameter:
3318             SetParamVal<ParamType::TMaterialParameter>(valueIn, valueOut);
3319             break;
3320         case ParamType::TMatrixType:
3321             SetParamVal<ParamType::TMatrixType>(valueIn, valueOut);
3322             break;
3323         case ParamType::TMemoryObjectID:
3324             SetParamVal<ParamType::TMemoryObjectID>(valueIn, valueOut);
3325             break;
3326         case ParamType::TMemoryObjectIDConstPointer:
3327             SetParamVal<ParamType::TMemoryObjectIDConstPointer>(valueIn, valueOut);
3328             break;
3329         case ParamType::TMemoryObjectIDPointer:
3330             SetParamVal<ParamType::TMemoryObjectIDPointer>(valueIn, valueOut);
3331             break;
3332         case ParamType::TObjectType:
3333             SetParamVal<ParamType::TObjectType>(valueIn, valueOut);
3334             break;
3335         case ParamType::TPointParameter:
3336             SetParamVal<ParamType::TPointParameter>(valueIn, valueOut);
3337             break;
3338         case ParamType::TPolygonMode:
3339             SetParamVal<ParamType::TPolygonMode>(valueIn, valueOut);
3340             break;
3341         case ParamType::TPrimitiveMode:
3342             SetParamVal<ParamType::TPrimitiveMode>(valueIn, valueOut);
3343             break;
3344         case ParamType::TProgramPipelineID:
3345             SetParamVal<ParamType::TProgramPipelineID>(valueIn, valueOut);
3346             break;
3347         case ParamType::TProgramPipelineIDConstPointer:
3348             SetParamVal<ParamType::TProgramPipelineIDConstPointer>(valueIn, valueOut);
3349             break;
3350         case ParamType::TProgramPipelineIDPointer:
3351             SetParamVal<ParamType::TProgramPipelineIDPointer>(valueIn, valueOut);
3352             break;
3353         case ParamType::TProvokingVertexConvention:
3354             SetParamVal<ParamType::TProvokingVertexConvention>(valueIn, valueOut);
3355             break;
3356         case ParamType::TQueryID:
3357             SetParamVal<ParamType::TQueryID>(valueIn, valueOut);
3358             break;
3359         case ParamType::TQueryIDConstPointer:
3360             SetParamVal<ParamType::TQueryIDConstPointer>(valueIn, valueOut);
3361             break;
3362         case ParamType::TQueryIDPointer:
3363             SetParamVal<ParamType::TQueryIDPointer>(valueIn, valueOut);
3364             break;
3365         case ParamType::TQueryType:
3366             SetParamVal<ParamType::TQueryType>(valueIn, valueOut);
3367             break;
3368         case ParamType::TRenderbufferID:
3369             SetParamVal<ParamType::TRenderbufferID>(valueIn, valueOut);
3370             break;
3371         case ParamType::TRenderbufferIDConstPointer:
3372             SetParamVal<ParamType::TRenderbufferIDConstPointer>(valueIn, valueOut);
3373             break;
3374         case ParamType::TRenderbufferIDPointer:
3375             SetParamVal<ParamType::TRenderbufferIDPointer>(valueIn, valueOut);
3376             break;
3377         case ParamType::TSamplerID:
3378             SetParamVal<ParamType::TSamplerID>(valueIn, valueOut);
3379             break;
3380         case ParamType::TSamplerIDConstPointer:
3381             SetParamVal<ParamType::TSamplerIDConstPointer>(valueIn, valueOut);
3382             break;
3383         case ParamType::TSamplerIDPointer:
3384             SetParamVal<ParamType::TSamplerIDPointer>(valueIn, valueOut);
3385             break;
3386         case ParamType::TSemaphoreID:
3387             SetParamVal<ParamType::TSemaphoreID>(valueIn, valueOut);
3388             break;
3389         case ParamType::TSemaphoreIDConstPointer:
3390             SetParamVal<ParamType::TSemaphoreIDConstPointer>(valueIn, valueOut);
3391             break;
3392         case ParamType::TSemaphoreIDPointer:
3393             SetParamVal<ParamType::TSemaphoreIDPointer>(valueIn, valueOut);
3394             break;
3395         case ParamType::TShaderProgramID:
3396             SetParamVal<ParamType::TShaderProgramID>(valueIn, valueOut);
3397             break;
3398         case ParamType::TShaderProgramIDConstPointer:
3399             SetParamVal<ParamType::TShaderProgramIDConstPointer>(valueIn, valueOut);
3400             break;
3401         case ParamType::TShaderProgramIDPointer:
3402             SetParamVal<ParamType::TShaderProgramIDPointer>(valueIn, valueOut);
3403             break;
3404         case ParamType::TShaderType:
3405             SetParamVal<ParamType::TShaderType>(valueIn, valueOut);
3406             break;
3407         case ParamType::TShadingModel:
3408             SetParamVal<ParamType::TShadingModel>(valueIn, valueOut);
3409             break;
3410         case ParamType::TSurfaceID:
3411             SetParamVal<ParamType::TSurfaceID>(valueIn, valueOut);
3412             break;
3413         case ParamType::TSyncID:
3414             SetParamVal<ParamType::TSyncID>(valueIn, valueOut);
3415             break;
3416         case ParamType::TTextureEnvParameter:
3417             SetParamVal<ParamType::TTextureEnvParameter>(valueIn, valueOut);
3418             break;
3419         case ParamType::TTextureEnvTarget:
3420             SetParamVal<ParamType::TTextureEnvTarget>(valueIn, valueOut);
3421             break;
3422         case ParamType::TTextureID:
3423             SetParamVal<ParamType::TTextureID>(valueIn, valueOut);
3424             break;
3425         case ParamType::TTextureIDConstPointer:
3426             SetParamVal<ParamType::TTextureIDConstPointer>(valueIn, valueOut);
3427             break;
3428         case ParamType::TTextureIDPointer:
3429             SetParamVal<ParamType::TTextureIDPointer>(valueIn, valueOut);
3430             break;
3431         case ParamType::TTextureTarget:
3432             SetParamVal<ParamType::TTextureTarget>(valueIn, valueOut);
3433             break;
3434         case ParamType::TTextureType:
3435             SetParamVal<ParamType::TTextureType>(valueIn, valueOut);
3436             break;
3437         case ParamType::TTimestamp:
3438             SetParamVal<ParamType::TTimestamp>(valueIn, valueOut);
3439             break;
3440         case ParamType::TTransformFeedbackID:
3441             SetParamVal<ParamType::TTransformFeedbackID>(valueIn, valueOut);
3442             break;
3443         case ParamType::TTransformFeedbackIDConstPointer:
3444             SetParamVal<ParamType::TTransformFeedbackIDConstPointer>(valueIn, valueOut);
3445             break;
3446         case ParamType::TTransformFeedbackIDPointer:
3447             SetParamVal<ParamType::TTransformFeedbackIDPointer>(valueIn, valueOut);
3448             break;
3449         case ParamType::TUniformBlockIndex:
3450             SetParamVal<ParamType::TUniformBlockIndex>(valueIn, valueOut);
3451             break;
3452         case ParamType::TUniformLocation:
3453             SetParamVal<ParamType::TUniformLocation>(valueIn, valueOut);
3454             break;
3455         case ParamType::TVertexArrayID:
3456             SetParamVal<ParamType::TVertexArrayID>(valueIn, valueOut);
3457             break;
3458         case ParamType::TVertexArrayIDConstPointer:
3459             SetParamVal<ParamType::TVertexArrayIDConstPointer>(valueIn, valueOut);
3460             break;
3461         case ParamType::TVertexArrayIDPointer:
3462             SetParamVal<ParamType::TVertexArrayIDPointer>(valueIn, valueOut);
3463             break;
3464         case ParamType::TVertexAttribType:
3465             SetParamVal<ParamType::TVertexAttribType>(valueIn, valueOut);
3466             break;
3467         case ParamType::TcharConstPointer:
3468             SetParamVal<ParamType::TcharConstPointer>(valueIn, valueOut);
3469             break;
3470         case ParamType::Tegl_ConfigPointer:
3471             SetParamVal<ParamType::Tegl_ConfigPointer>(valueIn, valueOut);
3472             break;
3473         case ParamType::Tegl_DevicePointer:
3474             SetParamVal<ParamType::Tegl_DevicePointer>(valueIn, valueOut);
3475             break;
3476         case ParamType::Tegl_DisplayPointer:
3477             SetParamVal<ParamType::Tegl_DisplayPointer>(valueIn, valueOut);
3478             break;
3479         case ParamType::Tegl_StreamPointer:
3480             SetParamVal<ParamType::Tegl_StreamPointer>(valueIn, valueOut);
3481             break;
3482         case ParamType::Tegl_SyncID:
3483             SetParamVal<ParamType::Tegl_SyncID>(valueIn, valueOut);
3484             break;
3485         case ParamType::TvoidConstPointer:
3486             SetParamVal<ParamType::TvoidConstPointer>(valueIn, valueOut);
3487             break;
3488         case ParamType::TvoidConstPointerPointer:
3489             SetParamVal<ParamType::TvoidConstPointerPointer>(valueIn, valueOut);
3490             break;
3491         case ParamType::TvoidPointer:
3492             SetParamVal<ParamType::TvoidPointer>(valueIn, valueOut);
3493             break;
3494         case ParamType::TvoidPointerPointer:
3495             SetParamVal<ParamType::TvoidPointerPointer>(valueIn, valueOut);
3496             break;
3497     }
3498 }
3499 
3500 struct CallCapture;
3501 struct ParamCapture;
3502 
3503 void WriteParamCaptureReplay(std::ostream &os, const CallCapture &call, const ParamCapture &param);
3504 const char *ParamTypeToString(ParamType paramType);
3505 
3506 enum class ResourceIDType
3507 {
3508     Buffer,
3509     Context,
3510     FenceNV,
3511     Framebuffer,
3512     Image,
3513     MemoryObject,
3514     ProgramPipeline,
3515     Query,
3516     Renderbuffer,
3517     Sampler,
3518     Semaphore,
3519     ShaderProgram,
3520     Surface,
3521     Sync,
3522     Texture,
3523     TransformFeedback,
3524     VertexArray,
3525     egl_Sync,
3526     EnumCount,
3527     InvalidEnum = EnumCount
3528 };
3529 
3530 ResourceIDType GetResourceIDTypeFromParamType(ParamType paramType);
3531 const char *GetResourceIDTypeName(ResourceIDType resourceIDType);
3532 
3533 template <typename ResourceType>
3534 struct GetResourceIDTypeFromType;
3535 
3536 template <>
3537 struct GetResourceIDTypeFromType<gl::BufferID>
3538 {
3539     static constexpr ResourceIDType IDType = ResourceIDType::Buffer;
3540 };
3541 
3542 template <>
3543 struct GetResourceIDTypeFromType<gl::ContextID>
3544 {
3545     static constexpr ResourceIDType IDType = ResourceIDType::Context;
3546 };
3547 
3548 template <>
3549 struct GetResourceIDTypeFromType<gl::FenceNVID>
3550 {
3551     static constexpr ResourceIDType IDType = ResourceIDType::FenceNV;
3552 };
3553 
3554 template <>
3555 struct GetResourceIDTypeFromType<gl::FramebufferID>
3556 {
3557     static constexpr ResourceIDType IDType = ResourceIDType::Framebuffer;
3558 };
3559 
3560 template <>
3561 struct GetResourceIDTypeFromType<egl::ImageID>
3562 {
3563     static constexpr ResourceIDType IDType = ResourceIDType::Image;
3564 };
3565 
3566 template <>
3567 struct GetResourceIDTypeFromType<gl::MemoryObjectID>
3568 {
3569     static constexpr ResourceIDType IDType = ResourceIDType::MemoryObject;
3570 };
3571 
3572 template <>
3573 struct GetResourceIDTypeFromType<gl::ProgramPipelineID>
3574 {
3575     static constexpr ResourceIDType IDType = ResourceIDType::ProgramPipeline;
3576 };
3577 
3578 template <>
3579 struct GetResourceIDTypeFromType<gl::QueryID>
3580 {
3581     static constexpr ResourceIDType IDType = ResourceIDType::Query;
3582 };
3583 
3584 template <>
3585 struct GetResourceIDTypeFromType<gl::RenderbufferID>
3586 {
3587     static constexpr ResourceIDType IDType = ResourceIDType::Renderbuffer;
3588 };
3589 
3590 template <>
3591 struct GetResourceIDTypeFromType<gl::SamplerID>
3592 {
3593     static constexpr ResourceIDType IDType = ResourceIDType::Sampler;
3594 };
3595 
3596 template <>
3597 struct GetResourceIDTypeFromType<gl::SemaphoreID>
3598 {
3599     static constexpr ResourceIDType IDType = ResourceIDType::Semaphore;
3600 };
3601 
3602 template <>
3603 struct GetResourceIDTypeFromType<gl::ShaderProgramID>
3604 {
3605     static constexpr ResourceIDType IDType = ResourceIDType::ShaderProgram;
3606 };
3607 
3608 template <>
3609 struct GetResourceIDTypeFromType<egl::SurfaceID>
3610 {
3611     static constexpr ResourceIDType IDType = ResourceIDType::Surface;
3612 };
3613 
3614 template <>
3615 struct GetResourceIDTypeFromType<gl::SyncID>
3616 {
3617     static constexpr ResourceIDType IDType = ResourceIDType::Sync;
3618 };
3619 
3620 template <>
3621 struct GetResourceIDTypeFromType<gl::TextureID>
3622 {
3623     static constexpr ResourceIDType IDType = ResourceIDType::Texture;
3624 };
3625 
3626 template <>
3627 struct GetResourceIDTypeFromType<gl::TransformFeedbackID>
3628 {
3629     static constexpr ResourceIDType IDType = ResourceIDType::TransformFeedback;
3630 };
3631 
3632 template <>
3633 struct GetResourceIDTypeFromType<gl::VertexArrayID>
3634 {
3635     static constexpr ResourceIDType IDType = ResourceIDType::VertexArray;
3636 };
3637 
3638 template <>
3639 struct GetResourceIDTypeFromType<egl::SyncID>
3640 {
3641     static constexpr ResourceIDType IDType = ResourceIDType::egl_Sync;
3642 };
3643 
3644 }  // namespace angle
3645 
3646 #endif  // COMMON_FRAME_CAPTURE_UTILS_AUTOGEN_H_
3647