[ tor-browser ].git.dasho

frame_capture_utils_autogen.h (104861B)
      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>
   1354 T GetParamVal(const ParamValue &value)
   1355 {
   1356    UNREACHABLE();
   1357    return T();
   1358 }
   1359 
   1360 template <typename T>
   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>
   2671 void SetParamVal(T valueIn, ParamValue *valueOut)
   2672 {
   2673    UNREACHABLE();
   2674 }
   2675 
   2676 template <typename T>
   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_
	tor-browser The Tor Browser
	git clone https://git.dasho.dev/tor-browser.git
	Log \| Files \| Refs \| README \| LICENSE