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