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