Edit

kc3-lang/angle/src/common/frame_capture_utils_autogen.h

Branch :

  • Show log

    Commit

  • Author : Steven Noonan
    Date : 2023-06-09 00:31:06
    Hash : a01a566c
    Message : extension xmls: fix incorrect use of <ptype> tags I was having trouble using some GL/EGL loader generators because of some errors in the XML definitions for ANGLE. The first major problem is the content of the <ptype> tags. Let's refer to the Khronos registry XML schema (which is annoyingly a PDF rather than an xsd that we can test against, though I don't know if an xsd would catch this anyway): https://raw.githubusercontent.com/KhronosGroup/OpenGL-Registry/master/xml/readme.pdf In section 12.4.2, "Contents of <param> tags" it states: The <ptype> tag is optional, and contains text which is a valid type name found in <type> tag, and indicates that this type must be previously defined for the definition of the command to succeed. Builtin C types, and any derived types which are expected to be found in other header files, should not be wrapped in <ptype> tags Note that the above is repeated for the contents of <proto> tags as well. The extension XML files currently have a bunch of <ptype> tags which don't meet the expectations described above. The correct transformation for them would be, for example: <ptype>GLfloat *</ptype> -> <ptype>GLfloat</ptype> * <ptype>void *</ptype> -> void * <ptype>const char *</ptype> -> const char * <ptype>EGLAttrib *</ptype> -> <ptype>EGLAttrib</ptype> * The next issue is that some tags have some typos, such as "<pytpe>" instead of "<ptype>". (Now *that* is something an .xsd would catch...) The last issue is the use of the typename "GLvoid" which is not as serious a problem. It is still defined in Khronos' gl.xml <types> block, but Khronos no longer uses it in their XML registries. The comment for the "GLvoid" type in their <types> block states: <type comment="Not an actual GL type, though used in headers in the past">typedef void <name>GLvoid</name>;</type> So we might as well replace those with just plain "void". Anyway, long story short: to apply these transformations, I used Perl regular expressions, and applied these expressions in order: - Fix the tag misspellings: s#<(/?)pytpe>#<\1ptype>#g - Move the const qualifiers (if present) and pointer asterisk(s) (if any) outside the <ptype> tag itself: s#<ptype>(const )?([A-Za-z0-9]+)[ ]?(\*\*?)</ptype> #\1<ptype>\2</ptype> \3#g - Replace "GLvoid", "char", and "void" inside ptype tags to normal C types outside tags: s#<ptype>(GLvoid|void|char)</ptype>#\1#g Bug: angleproject:8190 Change-Id: Ib0bea79fecb7e714910b6e92124bb9f52994d0fb Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4603709 Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org> Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>

  • src/common/frame_capture_utils_autogen.h
  • // GENERATED FILE - DO NOT EDIT.
    // Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml.
    //
    // Copyright 2020 The ANGLE Project Authors. All rights reserved.
    // Use of this source code is governed by a BSD-style license that can be
    // found in the LICENSE file.
    //
    // frame_capture_utils_autogen.h:
    //   ANGLE Frame capture types and helper functions.
    
    #ifndef COMMON_FRAME_CAPTURE_UTILS_AUTOGEN_H_
    #define COMMON_FRAME_CAPTURE_UTILS_AUTOGEN_H_
    
    #include "common/PackedEnums.h"
    
    namespace angle
    {
    enum class ParamType
    {
        TAHardwareBufferConstPointer,
        TAlphaTestFunc,
        TBufferBinding,
        TBufferID,
        TBufferIDConstPointer,
        TBufferIDPointer,
        TBufferUsage,
        TClientVertexArrayType,
        TClipDepthMode,
        TClipOrigin,
        TCompositorTiming,
        TContextID,
        TCullFaceMode,
        TDrawElementsType,
        TEGLAttribConstPointer,
        TEGLAttribKHRPointer,
        TEGLAttribPointer,
        TEGLBoolean,
        TEGLBooleanPointer,
        TEGLClientBuffer,
        TEGLConfigPointer,
        TEGLContext,
        TEGLDEBUGPROCKHR,
        TEGLDeviceEXT,
        TEGLDisplay,
        TEGLFrameTokenANGLE,
        TEGLGetBlobFuncANDROID,
        TEGLImage,
        TEGLImageKHR,
        TEGLLabelKHR,
        TEGLNativeDisplayType,
        TEGLNativePixmapType,
        TEGLNativeWindowType,
        TEGLObjectKHR,
        TEGLSetBlobFuncANDROID,
        TEGLStreamKHR,
        TEGLSurface,
        TEGLSync,
        TEGLSyncKHR,
        TEGLTime,
        TEGLTimeKHR,
        TEGLenum,
        TEGLint,
        TEGLintConstPointer,
        TEGLintPointer,
        TEGLnsecsANDROID,
        TEGLnsecsANDROIDPointer,
        TEGLuint64KHR,
        TEGLuint64KHRPointer,
        TFenceNVID,
        TFenceNVIDConstPointer,
        TFenceNVIDPointer,
        TFramebufferID,
        TFramebufferIDConstPointer,
        TFramebufferIDPointer,
        TGLDEBUGPROC,
        TGLDEBUGPROCKHR,
        TGLbitfield,
        TGLboolean,
        TGLbooleanConstPointer,
        TGLbooleanPointer,
        TGLbyte,
        TGLbyteConstPointer,
        TGLcharConstPointer,
        TGLcharConstPointerPointer,
        TGLcharPointer,
        TGLclampx,
        TGLdouble,
        TGLdoubleConstPointer,
        TGLdoublePointer,
        TGLeglClientBufferEXT,
        TGLenum,
        TGLenumConstPointer,
        TGLenumPointer,
        TGLfixed,
        TGLfixedConstPointer,
        TGLfixedPointer,
        TGLfloat,
        TGLfloatConstPointer,
        TGLfloatPointer,
        TGLint,
        TGLint64,
        TGLint64Pointer,
        TGLintConstPointer,
        TGLintPointer,
        TGLintptr,
        TGLintptrConstPointer,
        TGLshort,
        TGLshortConstPointer,
        TGLsizei,
        TGLsizeiConstPointer,
        TGLsizeiPointer,
        TGLsizeiptr,
        TGLsizeiptrConstPointer,
        TGLsync,
        TGLubyte,
        TGLubyteConstPointer,
        TGLubytePointer,
        TGLuint,
        TGLuint64,
        TGLuint64ConstPointer,
        TGLuint64Pointer,
        TGLuintConstPointer,
        TGLuintPointer,
        TGLushort,
        TGLushortConstPointer,
        TGLushortPointer,
        TGraphicsResetStatus,
        THandleType,
        TImageID,
        TLightParameter,
        TLogicalOperation,
        TMaterialParameter,
        TMatrixType,
        TMemoryObjectID,
        TMemoryObjectIDConstPointer,
        TMemoryObjectIDPointer,
        TObjectType,
        TPointParameter,
        TPolygonMode,
        TPrimitiveMode,
        TProgramPipelineID,
        TProgramPipelineIDConstPointer,
        TProgramPipelineIDPointer,
        TProvokingVertexConvention,
        TQueryID,
        TQueryIDConstPointer,
        TQueryIDPointer,
        TQueryType,
        TRenderbufferID,
        TRenderbufferIDConstPointer,
        TRenderbufferIDPointer,
        TSamplerID,
        TSamplerIDConstPointer,
        TSamplerIDPointer,
        TSemaphoreID,
        TSemaphoreIDConstPointer,
        TSemaphoreIDPointer,
        TShaderProgramID,
        TShaderProgramIDConstPointer,
        TShaderProgramIDPointer,
        TShaderType,
        TShadingModel,
        TSurfaceID,
        TSyncID,
        TTextureEnvParameter,
        TTextureEnvTarget,
        TTextureID,
        TTextureIDConstPointer,
        TTextureIDPointer,
        TTextureTarget,
        TTextureType,
        TTimestamp,
        TTransformFeedbackID,
        TTransformFeedbackIDConstPointer,
        TTransformFeedbackIDPointer,
        TUniformBlockIndex,
        TUniformLocation,
        TVertexArrayID,
        TVertexArrayIDConstPointer,
        TVertexArrayIDPointer,
        TVertexAttribType,
        TcharConstPointer,
        Tegl_ConfigPointer,
        Tegl_DevicePointer,
        Tegl_DisplayPointer,
        Tegl_StreamPointer,
        Tegl_SyncID,
        TvoidConstPointer,
        TvoidConstPointerPointer,
        TvoidPointer,
        TvoidPointerPointer,
    };
    
    constexpr uint32_t kParamTypeCount = 172;
    
    union ParamValue
    {
        const AHardwareBuffer *AHardwareBufferConstPointerVal;
        gl::AlphaTestFunc AlphaTestFuncVal;
        gl::BufferBinding BufferBindingVal;
        gl::BufferID BufferIDVal;
        const gl::BufferID *BufferIDConstPointerVal;
        gl::BufferID *BufferIDPointerVal;
        gl::BufferUsage BufferUsageVal;
        gl::ClientVertexArrayType ClientVertexArrayTypeVal;
        gl::ClipDepthMode ClipDepthModeVal;
        gl::ClipOrigin ClipOriginVal;
        egl::CompositorTiming CompositorTimingVal;
        gl::ContextID ContextIDVal;
        gl::CullFaceMode CullFaceModeVal;
        gl::DrawElementsType DrawElementsTypeVal;
        const EGLAttrib *EGLAttribConstPointerVal;
        EGLAttribKHR *EGLAttribKHRPointerVal;
        EGLAttrib *EGLAttribPointerVal;
        EGLBoolean EGLBooleanVal;
        EGLBoolean *EGLBooleanPointerVal;
        EGLClientBuffer EGLClientBufferVal;
        EGLConfig *EGLConfigPointerVal;
        EGLContext EGLContextVal;
        EGLDEBUGPROCKHR EGLDEBUGPROCKHRVal;
        EGLDeviceEXT EGLDeviceEXTVal;
        EGLDisplay EGLDisplayVal;
        EGLFrameTokenANGLE EGLFrameTokenANGLEVal;
        EGLGetBlobFuncANDROID EGLGetBlobFuncANDROIDVal;
        EGLImage EGLImageVal;
        EGLImageKHR EGLImageKHRVal;
        EGLLabelKHR EGLLabelKHRVal;
        EGLNativeDisplayType EGLNativeDisplayTypeVal;
        EGLNativePixmapType EGLNativePixmapTypeVal;
        EGLNativeWindowType EGLNativeWindowTypeVal;
        EGLObjectKHR EGLObjectKHRVal;
        EGLSetBlobFuncANDROID EGLSetBlobFuncANDROIDVal;
        EGLStreamKHR EGLStreamKHRVal;
        EGLSurface EGLSurfaceVal;
        EGLSync EGLSyncVal;
        EGLSyncKHR EGLSyncKHRVal;
        EGLTime EGLTimeVal;
        EGLTimeKHR EGLTimeKHRVal;
        EGLenum EGLenumVal;
        EGLint EGLintVal;
        const EGLint *EGLintConstPointerVal;
        EGLint *EGLintPointerVal;
        EGLnsecsANDROID EGLnsecsANDROIDVal;
        EGLnsecsANDROID *EGLnsecsANDROIDPointerVal;
        EGLuint64KHR EGLuint64KHRVal;
        EGLuint64KHR *EGLuint64KHRPointerVal;
        gl::FenceNVID FenceNVIDVal;
        const gl::FenceNVID *FenceNVIDConstPointerVal;
        gl::FenceNVID *FenceNVIDPointerVal;
        gl::FramebufferID FramebufferIDVal;
        const gl::FramebufferID *FramebufferIDConstPointerVal;
        gl::FramebufferID *FramebufferIDPointerVal;
        GLDEBUGPROC GLDEBUGPROCVal;
        GLDEBUGPROCKHR GLDEBUGPROCKHRVal;
        GLbitfield GLbitfieldVal;
        GLboolean GLbooleanVal;
        const GLboolean *GLbooleanConstPointerVal;
        GLboolean *GLbooleanPointerVal;
        GLbyte GLbyteVal;
        const GLbyte *GLbyteConstPointerVal;
        const GLchar *GLcharConstPointerVal;
        const GLchar *const *GLcharConstPointerPointerVal;
        GLchar *GLcharPointerVal;
        GLclampx GLclampxVal;
        GLdouble GLdoubleVal;
        const GLdouble *GLdoubleConstPointerVal;
        GLdouble *GLdoublePointerVal;
        GLeglClientBufferEXT GLeglClientBufferEXTVal;
        GLenum GLenumVal;
        const GLenum *GLenumConstPointerVal;
        GLenum *GLenumPointerVal;
        GLfixed GLfixedVal;
        const GLfixed *GLfixedConstPointerVal;
        GLfixed *GLfixedPointerVal;
        GLfloat GLfloatVal;
        const GLfloat *GLfloatConstPointerVal;
        GLfloat *GLfloatPointerVal;
        GLint GLintVal;
        GLint64 GLint64Val;
        GLint64 *GLint64PointerVal;
        const GLint *GLintConstPointerVal;
        GLint *GLintPointerVal;
        GLintptr GLintptrVal;
        const GLintptr *GLintptrConstPointerVal;
        GLshort GLshortVal;
        const GLshort *GLshortConstPointerVal;
        GLsizei GLsizeiVal;
        const GLsizei *GLsizeiConstPointerVal;
        GLsizei *GLsizeiPointerVal;
        GLsizeiptr GLsizeiptrVal;
        const GLsizeiptr *GLsizeiptrConstPointerVal;
        GLsync GLsyncVal;
        GLubyte GLubyteVal;
        const GLubyte *GLubyteConstPointerVal;
        GLubyte *GLubytePointerVal;
        GLuint GLuintVal;
        GLuint64 GLuint64Val;
        const GLuint64 *GLuint64ConstPointerVal;
        GLuint64 *GLuint64PointerVal;
        const GLuint *GLuintConstPointerVal;
        GLuint *GLuintPointerVal;
        GLushort GLushortVal;
        const GLushort *GLushortConstPointerVal;
        GLushort *GLushortPointerVal;
        gl::GraphicsResetStatus GraphicsResetStatusVal;
        gl::HandleType HandleTypeVal;
        egl::ImageID ImageIDVal;
        gl::LightParameter LightParameterVal;
        gl::LogicalOperation LogicalOperationVal;
        gl::MaterialParameter MaterialParameterVal;
        gl::MatrixType MatrixTypeVal;
        gl::MemoryObjectID MemoryObjectIDVal;
        const gl::MemoryObjectID *MemoryObjectIDConstPointerVal;
        gl::MemoryObjectID *MemoryObjectIDPointerVal;
        egl::ObjectType ObjectTypeVal;
        gl::PointParameter PointParameterVal;
        gl::PolygonMode PolygonModeVal;
        gl::PrimitiveMode PrimitiveModeVal;
        gl::ProgramPipelineID ProgramPipelineIDVal;
        const gl::ProgramPipelineID *ProgramPipelineIDConstPointerVal;
        gl::ProgramPipelineID *ProgramPipelineIDPointerVal;
        gl::ProvokingVertexConvention ProvokingVertexConventionVal;
        gl::QueryID QueryIDVal;
        const gl::QueryID *QueryIDConstPointerVal;
        gl::QueryID *QueryIDPointerVal;
        gl::QueryType QueryTypeVal;
        gl::RenderbufferID RenderbufferIDVal;
        const gl::RenderbufferID *RenderbufferIDConstPointerVal;
        gl::RenderbufferID *RenderbufferIDPointerVal;
        gl::SamplerID SamplerIDVal;
        const gl::SamplerID *SamplerIDConstPointerVal;
        gl::SamplerID *SamplerIDPointerVal;
        gl::SemaphoreID SemaphoreIDVal;
        const gl::SemaphoreID *SemaphoreIDConstPointerVal;
        gl::SemaphoreID *SemaphoreIDPointerVal;
        gl::ShaderProgramID ShaderProgramIDVal;
        const gl::ShaderProgramID *ShaderProgramIDConstPointerVal;
        gl::ShaderProgramID *ShaderProgramIDPointerVal;
        gl::ShaderType ShaderTypeVal;
        gl::ShadingModel ShadingModelVal;
        egl::SurfaceID SurfaceIDVal;
        gl::SyncID SyncIDVal;
        gl::TextureEnvParameter TextureEnvParameterVal;
        gl::TextureEnvTarget TextureEnvTargetVal;
        gl::TextureID TextureIDVal;
        const gl::TextureID *TextureIDConstPointerVal;
        gl::TextureID *TextureIDPointerVal;
        gl::TextureTarget TextureTargetVal;
        gl::TextureType TextureTypeVal;
        egl::Timestamp TimestampVal;
        gl::TransformFeedbackID TransformFeedbackIDVal;
        const gl::TransformFeedbackID *TransformFeedbackIDConstPointerVal;
        gl::TransformFeedbackID *TransformFeedbackIDPointerVal;
        gl::UniformBlockIndex UniformBlockIndexVal;
        gl::UniformLocation UniformLocationVal;
        gl::VertexArrayID VertexArrayIDVal;
        const gl::VertexArrayID *VertexArrayIDConstPointerVal;
        gl::VertexArrayID *VertexArrayIDPointerVal;
        gl::VertexAttribType VertexAttribTypeVal;
        const char *charConstPointerVal;
        egl::Config *egl_ConfigPointerVal;
        egl::Device *egl_DevicePointerVal;
        egl::Display *egl_DisplayPointerVal;
        egl::Stream *egl_StreamPointerVal;
        egl::SyncID egl_SyncIDVal;
        const void *voidConstPointerVal;
        const void *const *voidConstPointerPointerVal;
        void *voidPointerVal;
        void **voidPointerPointerVal;
    };
    
    template <ParamType PType, typename T>
    T GetParamVal(const ParamValue &value);
    
    template <>
    inline const AHardwareBuffer *GetParamVal<ParamType::TAHardwareBufferConstPointer,
                                              const AHardwareBuffer *>(const ParamValue &value)
    {
        return value.AHardwareBufferConstPointerVal;
    }
    
    template <>
    inline gl::AlphaTestFunc GetParamVal<ParamType::TAlphaTestFunc, gl::AlphaTestFunc>(
        const ParamValue &value)
    {
        return value.AlphaTestFuncVal;
    }
    
    template <>
    inline gl::BufferBinding GetParamVal<ParamType::TBufferBinding, gl::BufferBinding>(
        const ParamValue &value)
    {
        return value.BufferBindingVal;
    }
    
    template <>
    inline gl::BufferID GetParamVal<ParamType::TBufferID, gl::BufferID>(const ParamValue &value)
    {
        return value.BufferIDVal;
    }
    
    template <>
    inline const gl::BufferID *GetParamVal<ParamType::TBufferIDConstPointer, const gl::BufferID *>(
        const ParamValue &value)
    {
        return value.BufferIDConstPointerVal;
    }
    
    template <>
    inline gl::BufferID *GetParamVal<ParamType::TBufferIDPointer, gl::BufferID *>(
        const ParamValue &value)
    {
        return value.BufferIDPointerVal;
    }
    
    template <>
    inline gl::BufferUsage GetParamVal<ParamType::TBufferUsage, gl::BufferUsage>(
        const ParamValue &value)
    {
        return value.BufferUsageVal;
    }
    
    template <>
    inline gl::ClientVertexArrayType
    GetParamVal<ParamType::TClientVertexArrayType, gl::ClientVertexArrayType>(const ParamValue &value)
    {
        return value.ClientVertexArrayTypeVal;
    }
    
    template <>
    inline gl::ClipDepthMode GetParamVal<ParamType::TClipDepthMode, gl::ClipDepthMode>(
        const ParamValue &value)
    {
        return value.ClipDepthModeVal;
    }
    
    template <>
    inline gl::ClipOrigin GetParamVal<ParamType::TClipOrigin, gl::ClipOrigin>(const ParamValue &value)
    {
        return value.ClipOriginVal;
    }
    
    template <>
    inline egl::CompositorTiming GetParamVal<ParamType::TCompositorTiming, egl::CompositorTiming>(
        const ParamValue &value)
    {
        return value.CompositorTimingVal;
    }
    
    template <>
    inline gl::ContextID GetParamVal<ParamType::TContextID, gl::ContextID>(const ParamValue &value)
    {
        return value.ContextIDVal;
    }
    
    template <>
    inline gl::CullFaceMode GetParamVal<ParamType::TCullFaceMode, gl::CullFaceMode>(
        const ParamValue &value)
    {
        return value.CullFaceModeVal;
    }
    
    template <>
    inline gl::DrawElementsType GetParamVal<ParamType::TDrawElementsType, gl::DrawElementsType>(
        const ParamValue &value)
    {
        return value.DrawElementsTypeVal;
    }
    
    template <>
    inline const EGLAttrib *GetParamVal<ParamType::TEGLAttribConstPointer, const EGLAttrib *>(
        const ParamValue &value)
    {
        return value.EGLAttribConstPointerVal;
    }
    
    template <>
    inline EGLAttribKHR *GetParamVal<ParamType::TEGLAttribKHRPointer, EGLAttribKHR *>(
        const ParamValue &value)
    {
        return value.EGLAttribKHRPointerVal;
    }
    
    template <>
    inline EGLAttrib *GetParamVal<ParamType::TEGLAttribPointer, EGLAttrib *>(const ParamValue &value)
    {
        return value.EGLAttribPointerVal;
    }
    
    template <>
    inline EGLBoolean GetParamVal<ParamType::TEGLBoolean, EGLBoolean>(const ParamValue &value)
    {
        return value.EGLBooleanVal;
    }
    
    template <>
    inline EGLBoolean *GetParamVal<ParamType::TEGLBooleanPointer, EGLBoolean *>(const ParamValue &value)
    {
        return value.EGLBooleanPointerVal;
    }
    
    template <>
    inline EGLClientBuffer GetParamVal<ParamType::TEGLClientBuffer, EGLClientBuffer>(
        const ParamValue &value)
    {
        return value.EGLClientBufferVal;
    }
    
    template <>
    inline EGLConfig *GetParamVal<ParamType::TEGLConfigPointer, EGLConfig *>(const ParamValue &value)
    {
        return value.EGLConfigPointerVal;
    }
    
    template <>
    inline EGLContext GetParamVal<ParamType::TEGLContext, EGLContext>(const ParamValue &value)
    {
        return value.EGLContextVal;
    }
    
    template <>
    inline EGLDEBUGPROCKHR GetParamVal<ParamType::TEGLDEBUGPROCKHR, EGLDEBUGPROCKHR>(
        const ParamValue &value)
    {
        return value.EGLDEBUGPROCKHRVal;
    }
    
    template <>
    inline EGLDeviceEXT GetParamVal<ParamType::TEGLDeviceEXT, EGLDeviceEXT>(const ParamValue &value)
    {
        return value.EGLDeviceEXTVal;
    }
    
    template <>
    inline EGLDisplay GetParamVal<ParamType::TEGLDisplay, EGLDisplay>(const ParamValue &value)
    {
        return value.EGLDisplayVal;
    }
    
    template <>
    inline EGLFrameTokenANGLE GetParamVal<ParamType::TEGLFrameTokenANGLE, EGLFrameTokenANGLE>(
        const ParamValue &value)
    {
        return value.EGLFrameTokenANGLEVal;
    }
    
    template <>
    inline EGLGetBlobFuncANDROID GetParamVal<ParamType::TEGLGetBlobFuncANDROID, EGLGetBlobFuncANDROID>(
        const ParamValue &value)
    {
        return value.EGLGetBlobFuncANDROIDVal;
    }
    
    template <>
    inline EGLImage GetParamVal<ParamType::TEGLImage, EGLImage>(const ParamValue &value)
    {
        return value.EGLImageVal;
    }
    
    template <>
    inline EGLImageKHR GetParamVal<ParamType::TEGLImageKHR, EGLImageKHR>(const ParamValue &value)
    {
        return value.EGLImageKHRVal;
    }
    
    template <>
    inline EGLLabelKHR GetParamVal<ParamType::TEGLLabelKHR, EGLLabelKHR>(const ParamValue &value)
    {
        return value.EGLLabelKHRVal;
    }
    
    template <>
    inline EGLNativeDisplayType GetParamVal<ParamType::TEGLNativeDisplayType, EGLNativeDisplayType>(
        const ParamValue &value)
    {
        return value.EGLNativeDisplayTypeVal;
    }
    
    template <>
    inline EGLNativePixmapType GetParamVal<ParamType::TEGLNativePixmapType, EGLNativePixmapType>(
        const ParamValue &value)
    {
        return value.EGLNativePixmapTypeVal;
    }
    
    template <>
    inline EGLNativeWindowType GetParamVal<ParamType::TEGLNativeWindowType, EGLNativeWindowType>(
        const ParamValue &value)
    {
        return value.EGLNativeWindowTypeVal;
    }
    
    template <>
    inline EGLObjectKHR GetParamVal<ParamType::TEGLObjectKHR, EGLObjectKHR>(const ParamValue &value)
    {
        return value.EGLObjectKHRVal;
    }
    
    template <>
    inline EGLSetBlobFuncANDROID GetParamVal<ParamType::TEGLSetBlobFuncANDROID, EGLSetBlobFuncANDROID>(
        const ParamValue &value)
    {
        return value.EGLSetBlobFuncANDROIDVal;
    }
    
    template <>
    inline EGLStreamKHR GetParamVal<ParamType::TEGLStreamKHR, EGLStreamKHR>(const ParamValue &value)
    {
        return value.EGLStreamKHRVal;
    }
    
    template <>
    inline EGLSurface GetParamVal<ParamType::TEGLSurface, EGLSurface>(const ParamValue &value)
    {
        return value.EGLSurfaceVal;
    }
    
    template <>
    inline EGLSync GetParamVal<ParamType::TEGLSync, EGLSync>(const ParamValue &value)
    {
        return value.EGLSyncVal;
    }
    
    template <>
    inline EGLSyncKHR GetParamVal<ParamType::TEGLSyncKHR, EGLSyncKHR>(const ParamValue &value)
    {
        return value.EGLSyncKHRVal;
    }
    
    template <>
    inline EGLTime GetParamVal<ParamType::TEGLTime, EGLTime>(const ParamValue &value)
    {
        return value.EGLTimeVal;
    }
    
    template <>
    inline EGLTimeKHR GetParamVal<ParamType::TEGLTimeKHR, EGLTimeKHR>(const ParamValue &value)
    {
        return value.EGLTimeKHRVal;
    }
    
    template <>
    inline EGLenum GetParamVal<ParamType::TEGLenum, EGLenum>(const ParamValue &value)
    {
        return value.EGLenumVal;
    }
    
    template <>
    inline EGLint GetParamVal<ParamType::TEGLint, EGLint>(const ParamValue &value)
    {
        return value.EGLintVal;
    }
    
    template <>
    inline const EGLint *GetParamVal<ParamType::TEGLintConstPointer, const EGLint *>(
        const ParamValue &value)
    {
        return value.EGLintConstPointerVal;
    }
    
    template <>
    inline EGLint *GetParamVal<ParamType::TEGLintPointer, EGLint *>(const ParamValue &value)
    {
        return value.EGLintPointerVal;
    }
    
    template <>
    inline EGLnsecsANDROID GetParamVal<ParamType::TEGLnsecsANDROID, EGLnsecsANDROID>(
        const ParamValue &value)
    {
        return value.EGLnsecsANDROIDVal;
    }
    
    template <>
    inline EGLnsecsANDROID *GetParamVal<ParamType::TEGLnsecsANDROIDPointer, EGLnsecsANDROID *>(
        const ParamValue &value)
    {
        return value.EGLnsecsANDROIDPointerVal;
    }
    
    template <>
    inline EGLuint64KHR GetParamVal<ParamType::TEGLuint64KHR, EGLuint64KHR>(const ParamValue &value)
    {
        return value.EGLuint64KHRVal;
    }
    
    template <>
    inline EGLuint64KHR *GetParamVal<ParamType::TEGLuint64KHRPointer, EGLuint64KHR *>(
        const ParamValue &value)
    {
        return value.EGLuint64KHRPointerVal;
    }
    
    template <>
    inline gl::FenceNVID GetParamVal<ParamType::TFenceNVID, gl::FenceNVID>(const ParamValue &value)
    {
        return value.FenceNVIDVal;
    }
    
    template <>
    inline const gl::FenceNVID *GetParamVal<ParamType::TFenceNVIDConstPointer, const gl::FenceNVID *>(
        const ParamValue &value)
    {
        return value.FenceNVIDConstPointerVal;
    }
    
    template <>
    inline gl::FenceNVID *GetParamVal<ParamType::TFenceNVIDPointer, gl::FenceNVID *>(
        const ParamValue &value)
    {
        return value.FenceNVIDPointerVal;
    }
    
    template <>
    inline gl::FramebufferID GetParamVal<ParamType::TFramebufferID, gl::FramebufferID>(
        const ParamValue &value)
    {
        return value.FramebufferIDVal;
    }
    
    template <>
    inline const gl::FramebufferID *GetParamVal<ParamType::TFramebufferIDConstPointer,
                                                const gl::FramebufferID *>(const ParamValue &value)
    {
        return value.FramebufferIDConstPointerVal;
    }
    
    template <>
    inline gl::FramebufferID *GetParamVal<ParamType::TFramebufferIDPointer, gl::FramebufferID *>(
        const ParamValue &value)
    {
        return value.FramebufferIDPointerVal;
    }
    
    template <>
    inline GLDEBUGPROC GetParamVal<ParamType::TGLDEBUGPROC, GLDEBUGPROC>(const ParamValue &value)
    {
        return value.GLDEBUGPROCVal;
    }
    
    template <>
    inline GLDEBUGPROCKHR GetParamVal<ParamType::TGLDEBUGPROCKHR, GLDEBUGPROCKHR>(
        const ParamValue &value)
    {
        return value.GLDEBUGPROCKHRVal;
    }
    
    template <>
    inline GLbitfield GetParamVal<ParamType::TGLbitfield, GLbitfield>(const ParamValue &value)
    {
        return value.GLbitfieldVal;
    }
    
    template <>
    inline GLboolean GetParamVal<ParamType::TGLboolean, GLboolean>(const ParamValue &value)
    {
        return value.GLbooleanVal;
    }
    
    template <>
    inline const GLboolean *GetParamVal<ParamType::TGLbooleanConstPointer, const GLboolean *>(
        const ParamValue &value)
    {
        return value.GLbooleanConstPointerVal;
    }
    
    template <>
    inline GLboolean *GetParamVal<ParamType::TGLbooleanPointer, GLboolean *>(const ParamValue &value)
    {
        return value.GLbooleanPointerVal;
    }
    
    template <>
    inline GLbyte GetParamVal<ParamType::TGLbyte, GLbyte>(const ParamValue &value)
    {
        return value.GLbyteVal;
    }
    
    template <>
    inline const GLbyte *GetParamVal<ParamType::TGLbyteConstPointer, const GLbyte *>(
        const ParamValue &value)
    {
        return value.GLbyteConstPointerVal;
    }
    
    template <>
    inline const GLchar *GetParamVal<ParamType::TGLcharConstPointer, const GLchar *>(
        const ParamValue &value)
    {
        return value.GLcharConstPointerVal;
    }
    
    template <>
    inline const GLchar *const *
    GetParamVal<ParamType::TGLcharConstPointerPointer, const GLchar *const *>(const ParamValue &value)
    {
        return value.GLcharConstPointerPointerVal;
    }
    
    template <>
    inline GLchar *GetParamVal<ParamType::TGLcharPointer, GLchar *>(const ParamValue &value)
    {
        return value.GLcharPointerVal;
    }
    
    template <>
    inline GLclampx GetParamVal<ParamType::TGLclampx, GLclampx>(const ParamValue &value)
    {
        return value.GLclampxVal;
    }
    
    template <>
    inline GLdouble GetParamVal<ParamType::TGLdouble, GLdouble>(const ParamValue &value)
    {
        return value.GLdoubleVal;
    }
    
    template <>
    inline const GLdouble *GetParamVal<ParamType::TGLdoubleConstPointer, const GLdouble *>(
        const ParamValue &value)
    {
        return value.GLdoubleConstPointerVal;
    }
    
    template <>
    inline GLdouble *GetParamVal<ParamType::TGLdoublePointer, GLdouble *>(const ParamValue &value)
    {
        return value.GLdoublePointerVal;
    }
    
    template <>
    inline GLeglClientBufferEXT GetParamVal<ParamType::TGLeglClientBufferEXT, GLeglClientBufferEXT>(
        const ParamValue &value)
    {
        return value.GLeglClientBufferEXTVal;
    }
    
    template <>
    inline GLenum GetParamVal<ParamType::TGLenum, GLenum>(const ParamValue &value)
    {
        return value.GLenumVal;
    }
    
    template <>
    inline const GLenum *GetParamVal<ParamType::TGLenumConstPointer, const GLenum *>(
        const ParamValue &value)
    {
        return value.GLenumConstPointerVal;
    }
    
    template <>
    inline GLenum *GetParamVal<ParamType::TGLenumPointer, GLenum *>(const ParamValue &value)
    {
        return value.GLenumPointerVal;
    }
    
    template <>
    inline GLfixed GetParamVal<ParamType::TGLfixed, GLfixed>(const ParamValue &value)
    {
        return value.GLfixedVal;
    }
    
    template <>
    inline const GLfixed *GetParamVal<ParamType::TGLfixedConstPointer, const GLfixed *>(
        const ParamValue &value)
    {
        return value.GLfixedConstPointerVal;
    }
    
    template <>
    inline GLfixed *GetParamVal<ParamType::TGLfixedPointer, GLfixed *>(const ParamValue &value)
    {
        return value.GLfixedPointerVal;
    }
    
    template <>
    inline GLfloat GetParamVal<ParamType::TGLfloat, GLfloat>(const ParamValue &value)
    {
        return value.GLfloatVal;
    }
    
    template <>
    inline const GLfloat *GetParamVal<ParamType::TGLfloatConstPointer, const GLfloat *>(
        const ParamValue &value)
    {
        return value.GLfloatConstPointerVal;
    }
    
    template <>
    inline GLfloat *GetParamVal<ParamType::TGLfloatPointer, GLfloat *>(const ParamValue &value)
    {
        return value.GLfloatPointerVal;
    }
    
    template <>
    inline GLint GetParamVal<ParamType::TGLint, GLint>(const ParamValue &value)
    {
        return value.GLintVal;
    }
    
    template <>
    inline GLint64 GetParamVal<ParamType::TGLint64, GLint64>(const ParamValue &value)
    {
        return value.GLint64Val;
    }
    
    template <>
    inline GLint64 *GetParamVal<ParamType::TGLint64Pointer, GLint64 *>(const ParamValue &value)
    {
        return value.GLint64PointerVal;
    }
    
    template <>
    inline const GLint *GetParamVal<ParamType::TGLintConstPointer, const GLint *>(
        const ParamValue &value)
    {
        return value.GLintConstPointerVal;
    }
    
    template <>
    inline GLint *GetParamVal<ParamType::TGLintPointer, GLint *>(const ParamValue &value)
    {
        return value.GLintPointerVal;
    }
    
    template <>
    inline GLintptr GetParamVal<ParamType::TGLintptr, GLintptr>(const ParamValue &value)
    {
        return value.GLintptrVal;
    }
    
    template <>
    inline const GLintptr *GetParamVal<ParamType::TGLintptrConstPointer, const GLintptr *>(
        const ParamValue &value)
    {
        return value.GLintptrConstPointerVal;
    }
    
    template <>
    inline GLshort GetParamVal<ParamType::TGLshort, GLshort>(const ParamValue &value)
    {
        return value.GLshortVal;
    }
    
    template <>
    inline const GLshort *GetParamVal<ParamType::TGLshortConstPointer, const GLshort *>(
        const ParamValue &value)
    {
        return value.GLshortConstPointerVal;
    }
    
    template <>
    inline GLsizei GetParamVal<ParamType::TGLsizei, GLsizei>(const ParamValue &value)
    {
        return value.GLsizeiVal;
    }
    
    template <>
    inline const GLsizei *GetParamVal<ParamType::TGLsizeiConstPointer, const GLsizei *>(
        const ParamValue &value)
    {
        return value.GLsizeiConstPointerVal;
    }
    
    template <>
    inline GLsizei *GetParamVal<ParamType::TGLsizeiPointer, GLsizei *>(const ParamValue &value)
    {
        return value.GLsizeiPointerVal;
    }
    
    template <>
    inline GLsizeiptr GetParamVal<ParamType::TGLsizeiptr, GLsizeiptr>(const ParamValue &value)
    {
        return value.GLsizeiptrVal;
    }
    
    template <>
    inline const GLsizeiptr *GetParamVal<ParamType::TGLsizeiptrConstPointer, const GLsizeiptr *>(
        const ParamValue &value)
    {
        return value.GLsizeiptrConstPointerVal;
    }
    
    template <>
    inline GLsync GetParamVal<ParamType::TGLsync, GLsync>(const ParamValue &value)
    {
        return value.GLsyncVal;
    }
    
    template <>
    inline GLubyte GetParamVal<ParamType::TGLubyte, GLubyte>(const ParamValue &value)
    {
        return value.GLubyteVal;
    }
    
    template <>
    inline const GLubyte *GetParamVal<ParamType::TGLubyteConstPointer, const GLubyte *>(
        const ParamValue &value)
    {
        return value.GLubyteConstPointerVal;
    }
    
    template <>
    inline GLubyte *GetParamVal<ParamType::TGLubytePointer, GLubyte *>(const ParamValue &value)
    {
        return value.GLubytePointerVal;
    }
    
    template <>
    inline GLuint GetParamVal<ParamType::TGLuint, GLuint>(const ParamValue &value)
    {
        return value.GLuintVal;
    }
    
    template <>
    inline GLuint64 GetParamVal<ParamType::TGLuint64, GLuint64>(const ParamValue &value)
    {
        return value.GLuint64Val;
    }
    
    template <>
    inline const GLuint64 *GetParamVal<ParamType::TGLuint64ConstPointer, const GLuint64 *>(
        const ParamValue &value)
    {
        return value.GLuint64ConstPointerVal;
    }
    
    template <>
    inline GLuint64 *GetParamVal<ParamType::TGLuint64Pointer, GLuint64 *>(const ParamValue &value)
    {
        return value.GLuint64PointerVal;
    }
    
    template <>
    inline const GLuint *GetParamVal<ParamType::TGLuintConstPointer, const GLuint *>(
        const ParamValue &value)
    {
        return value.GLuintConstPointerVal;
    }
    
    template <>
    inline GLuint *GetParamVal<ParamType::TGLuintPointer, GLuint *>(const ParamValue &value)
    {
        return value.GLuintPointerVal;
    }
    
    template <>
    inline GLushort GetParamVal<ParamType::TGLushort, GLushort>(const ParamValue &value)
    {
        return value.GLushortVal;
    }
    
    template <>
    inline const GLushort *GetParamVal<ParamType::TGLushortConstPointer, const GLushort *>(
        const ParamValue &value)
    {
        return value.GLushortConstPointerVal;
    }
    
    template <>
    inline GLushort *GetParamVal<ParamType::TGLushortPointer, GLushort *>(const ParamValue &value)
    {
        return value.GLushortPointerVal;
    }
    
    template <>
    inline gl::GraphicsResetStatus
    GetParamVal<ParamType::TGraphicsResetStatus, gl::GraphicsResetStatus>(const ParamValue &value)
    {
        return value.GraphicsResetStatusVal;
    }
    
    template <>
    inline gl::HandleType GetParamVal<ParamType::THandleType, gl::HandleType>(const ParamValue &value)
    {
        return value.HandleTypeVal;
    }
    
    template <>
    inline egl::ImageID GetParamVal<ParamType::TImageID, egl::ImageID>(const ParamValue &value)
    {
        return value.ImageIDVal;
    }
    
    template <>
    inline gl::LightParameter GetParamVal<ParamType::TLightParameter, gl::LightParameter>(
        const ParamValue &value)
    {
        return value.LightParameterVal;
    }
    
    template <>
    inline gl::LogicalOperation GetParamVal<ParamType::TLogicalOperation, gl::LogicalOperation>(
        const ParamValue &value)
    {
        return value.LogicalOperationVal;
    }
    
    template <>
    inline gl::MaterialParameter GetParamVal<ParamType::TMaterialParameter, gl::MaterialParameter>(
        const ParamValue &value)
    {
        return value.MaterialParameterVal;
    }
    
    template <>
    inline gl::MatrixType GetParamVal<ParamType::TMatrixType, gl::MatrixType>(const ParamValue &value)
    {
        return value.MatrixTypeVal;
    }
    
    template <>
    inline gl::MemoryObjectID GetParamVal<ParamType::TMemoryObjectID, gl::MemoryObjectID>(
        const ParamValue &value)
    {
        return value.MemoryObjectIDVal;
    }
    
    template <>
    inline const gl::MemoryObjectID *GetParamVal<ParamType::TMemoryObjectIDConstPointer,
                                                 const gl::MemoryObjectID *>(const ParamValue &value)
    {
        return value.MemoryObjectIDConstPointerVal;
    }
    
    template <>
    inline gl::MemoryObjectID *GetParamVal<ParamType::TMemoryObjectIDPointer, gl::MemoryObjectID *>(
        const ParamValue &value)
    {
        return value.MemoryObjectIDPointerVal;
    }
    
    template <>
    inline egl::ObjectType GetParamVal<ParamType::TObjectType, egl::ObjectType>(const ParamValue &value)
    {
        return value.ObjectTypeVal;
    }
    
    template <>
    inline gl::PointParameter GetParamVal<ParamType::TPointParameter, gl::PointParameter>(
        const ParamValue &value)
    {
        return value.PointParameterVal;
    }
    
    template <>
    inline gl::PolygonMode GetParamVal<ParamType::TPolygonMode, gl::PolygonMode>(
        const ParamValue &value)
    {
        return value.PolygonModeVal;
    }
    
    template <>
    inline gl::PrimitiveMode GetParamVal<ParamType::TPrimitiveMode, gl::PrimitiveMode>(
        const ParamValue &value)
    {
        return value.PrimitiveModeVal;
    }
    
    template <>
    inline gl::ProgramPipelineID GetParamVal<ParamType::TProgramPipelineID, gl::ProgramPipelineID>(
        const ParamValue &value)
    {
        return value.ProgramPipelineIDVal;
    }
    
    template <>
    inline const gl::ProgramPipelineID *
    GetParamVal<ParamType::TProgramPipelineIDConstPointer, const gl::ProgramPipelineID *>(
        const ParamValue &value)
    {
        return value.ProgramPipelineIDConstPointerVal;
    }
    
    template <>
    inline gl::ProgramPipelineID *
    GetParamVal<ParamType::TProgramPipelineIDPointer, gl::ProgramPipelineID *>(const ParamValue &value)
    {
        return value.ProgramPipelineIDPointerVal;
    }
    
    template <>
    inline gl::ProvokingVertexConvention
    GetParamVal<ParamType::TProvokingVertexConvention, gl::ProvokingVertexConvention>(
        const ParamValue &value)
    {
        return value.ProvokingVertexConventionVal;
    }
    
    template <>
    inline gl::QueryID GetParamVal<ParamType::TQueryID, gl::QueryID>(const ParamValue &value)
    {
        return value.QueryIDVal;
    }
    
    template <>
    inline const gl::QueryID *GetParamVal<ParamType::TQueryIDConstPointer, const gl::QueryID *>(
        const ParamValue &value)
    {
        return value.QueryIDConstPointerVal;
    }
    
    template <>
    inline gl::QueryID *GetParamVal<ParamType::TQueryIDPointer, gl::QueryID *>(const ParamValue &value)
    {
        return value.QueryIDPointerVal;
    }
    
    template <>
    inline gl::QueryType GetParamVal<ParamType::TQueryType, gl::QueryType>(const ParamValue &value)
    {
        return value.QueryTypeVal;
    }
    
    template <>
    inline gl::RenderbufferID GetParamVal<ParamType::TRenderbufferID, gl::RenderbufferID>(
        const ParamValue &value)
    {
        return value.RenderbufferIDVal;
    }
    
    template <>
    inline const gl::RenderbufferID *GetParamVal<ParamType::TRenderbufferIDConstPointer,
                                                 const gl::RenderbufferID *>(const ParamValue &value)
    {
        return value.RenderbufferIDConstPointerVal;
    }
    
    template <>
    inline gl::RenderbufferID *GetParamVal<ParamType::TRenderbufferIDPointer, gl::RenderbufferID *>(
        const ParamValue &value)
    {
        return value.RenderbufferIDPointerVal;
    }
    
    template <>
    inline gl::SamplerID GetParamVal<ParamType::TSamplerID, gl::SamplerID>(const ParamValue &value)
    {
        return value.SamplerIDVal;
    }
    
    template <>
    inline const gl::SamplerID *GetParamVal<ParamType::TSamplerIDConstPointer, const gl::SamplerID *>(
        const ParamValue &value)
    {
        return value.SamplerIDConstPointerVal;
    }
    
    template <>
    inline gl::SamplerID *GetParamVal<ParamType::TSamplerIDPointer, gl::SamplerID *>(
        const ParamValue &value)
    {
        return value.SamplerIDPointerVal;
    }
    
    template <>
    inline gl::SemaphoreID GetParamVal<ParamType::TSemaphoreID, gl::SemaphoreID>(
        const ParamValue &value)
    {
        return value.SemaphoreIDVal;
    }
    
    template <>
    inline const gl::SemaphoreID *
    GetParamVal<ParamType::TSemaphoreIDConstPointer, const gl::SemaphoreID *>(const ParamValue &value)
    {
        return value.SemaphoreIDConstPointerVal;
    }
    
    template <>
    inline gl::SemaphoreID *GetParamVal<ParamType::TSemaphoreIDPointer, gl::SemaphoreID *>(
        const ParamValue &value)
    {
        return value.SemaphoreIDPointerVal;
    }
    
    template <>
    inline gl::ShaderProgramID GetParamVal<ParamType::TShaderProgramID, gl::ShaderProgramID>(
        const ParamValue &value)
    {
        return value.ShaderProgramIDVal;
    }
    
    template <>
    inline const gl::ShaderProgramID *GetParamVal<ParamType::TShaderProgramIDConstPointer,
                                                  const gl::ShaderProgramID *>(const ParamValue &value)
    {
        return value.ShaderProgramIDConstPointerVal;
    }
    
    template <>
    inline gl::ShaderProgramID *GetParamVal<ParamType::TShaderProgramIDPointer, gl::ShaderProgramID *>(
        const ParamValue &value)
    {
        return value.ShaderProgramIDPointerVal;
    }
    
    template <>
    inline gl::ShaderType GetParamVal<ParamType::TShaderType, gl::ShaderType>(const ParamValue &value)
    {
        return value.ShaderTypeVal;
    }
    
    template <>
    inline gl::ShadingModel GetParamVal<ParamType::TShadingModel, gl::ShadingModel>(
        const ParamValue &value)
    {
        return value.ShadingModelVal;
    }
    
    template <>
    inline egl::SurfaceID GetParamVal<ParamType::TSurfaceID, egl::SurfaceID>(const ParamValue &value)
    {
        return value.SurfaceIDVal;
    }
    
    template <>
    inline gl::SyncID GetParamVal<ParamType::TSyncID, gl::SyncID>(const ParamValue &value)
    {
        return value.SyncIDVal;
    }
    
    template <>
    inline gl::TextureEnvParameter
    GetParamVal<ParamType::TTextureEnvParameter, gl::TextureEnvParameter>(const ParamValue &value)
    {
        return value.TextureEnvParameterVal;
    }
    
    template <>
    inline gl::TextureEnvTarget GetParamVal<ParamType::TTextureEnvTarget, gl::TextureEnvTarget>(
        const ParamValue &value)
    {
        return value.TextureEnvTargetVal;
    }
    
    template <>
    inline gl::TextureID GetParamVal<ParamType::TTextureID, gl::TextureID>(const ParamValue &value)
    {
        return value.TextureIDVal;
    }
    
    template <>
    inline const gl::TextureID *GetParamVal<ParamType::TTextureIDConstPointer, const gl::TextureID *>(
        const ParamValue &value)
    {
        return value.TextureIDConstPointerVal;
    }
    
    template <>
    inline gl::TextureID *GetParamVal<ParamType::TTextureIDPointer, gl::TextureID *>(
        const ParamValue &value)
    {
        return value.TextureIDPointerVal;
    }
    
    template <>
    inline gl::TextureTarget GetParamVal<ParamType::TTextureTarget, gl::TextureTarget>(
        const ParamValue &value)
    {
        return value.TextureTargetVal;
    }
    
    template <>
    inline gl::TextureType GetParamVal<ParamType::TTextureType, gl::TextureType>(
        const ParamValue &value)
    {
        return value.TextureTypeVal;
    }
    
    template <>
    inline egl::Timestamp GetParamVal<ParamType::TTimestamp, egl::Timestamp>(const ParamValue &value)
    {
        return value.TimestampVal;
    }
    
    template <>
    inline gl::TransformFeedbackID
    GetParamVal<ParamType::TTransformFeedbackID, gl::TransformFeedbackID>(const ParamValue &value)
    {
        return value.TransformFeedbackIDVal;
    }
    
    template <>
    inline const gl::TransformFeedbackID *
    GetParamVal<ParamType::TTransformFeedbackIDConstPointer, const gl::TransformFeedbackID *>(
        const ParamValue &value)
    {
        return value.TransformFeedbackIDConstPointerVal;
    }
    
    template <>
    inline gl::TransformFeedbackID *GetParamVal<ParamType::TTransformFeedbackIDPointer,
                                                gl::TransformFeedbackID *>(const ParamValue &value)
    {
        return value.TransformFeedbackIDPointerVal;
    }
    
    template <>
    inline gl::UniformBlockIndex GetParamVal<ParamType::TUniformBlockIndex, gl::UniformBlockIndex>(
        const ParamValue &value)
    {
        return value.UniformBlockIndexVal;
    }
    
    template <>
    inline gl::UniformLocation GetParamVal<ParamType::TUniformLocation, gl::UniformLocation>(
        const ParamValue &value)
    {
        return value.UniformLocationVal;
    }
    
    template <>
    inline gl::VertexArrayID GetParamVal<ParamType::TVertexArrayID, gl::VertexArrayID>(
        const ParamValue &value)
    {
        return value.VertexArrayIDVal;
    }
    
    template <>
    inline const gl::VertexArrayID *GetParamVal<ParamType::TVertexArrayIDConstPointer,
                                                const gl::VertexArrayID *>(const ParamValue &value)
    {
        return value.VertexArrayIDConstPointerVal;
    }
    
    template <>
    inline gl::VertexArrayID *GetParamVal<ParamType::TVertexArrayIDPointer, gl::VertexArrayID *>(
        const ParamValue &value)
    {
        return value.VertexArrayIDPointerVal;
    }
    
    template <>
    inline gl::VertexAttribType GetParamVal<ParamType::TVertexAttribType, gl::VertexAttribType>(
        const ParamValue &value)
    {
        return value.VertexAttribTypeVal;
    }
    
    template <>
    inline const char *GetParamVal<ParamType::TcharConstPointer, const char *>(const ParamValue &value)
    {
        return value.charConstPointerVal;
    }
    
    template <>
    inline egl::Config *GetParamVal<ParamType::Tegl_ConfigPointer, egl::Config *>(
        const ParamValue &value)
    {
        return value.egl_ConfigPointerVal;
    }
    
    template <>
    inline egl::Device *GetParamVal<ParamType::Tegl_DevicePointer, egl::Device *>(
        const ParamValue &value)
    {
        return value.egl_DevicePointerVal;
    }
    
    template <>
    inline egl::Display *GetParamVal<ParamType::Tegl_DisplayPointer, egl::Display *>(
        const ParamValue &value)
    {
        return value.egl_DisplayPointerVal;
    }
    
    template <>
    inline egl::Stream *GetParamVal<ParamType::Tegl_StreamPointer, egl::Stream *>(
        const ParamValue &value)
    {
        return value.egl_StreamPointerVal;
    }
    
    template <>
    inline egl::SyncID GetParamVal<ParamType::Tegl_SyncID, egl::SyncID>(const ParamValue &value)
    {
        return value.egl_SyncIDVal;
    }
    
    template <>
    inline const void *GetParamVal<ParamType::TvoidConstPointer, const void *>(const ParamValue &value)
    {
        return value.voidConstPointerVal;
    }
    
    template <>
    inline const void *const *GetParamVal<ParamType::TvoidConstPointerPointer, const void *const *>(
        const ParamValue &value)
    {
        return value.voidConstPointerPointerVal;
    }
    
    template <>
    inline void *GetParamVal<ParamType::TvoidPointer, void *>(const ParamValue &value)
    {
        return value.voidPointerVal;
    }
    
    template <>
    inline void **GetParamVal<ParamType::TvoidPointerPointer, void **>(const ParamValue &value)
    {
        return value.voidPointerPointerVal;
    }
    
    template <ParamType PType, typename T>
    T GetParamVal(const ParamValue &value)
    {
        UNREACHABLE();
        return T();
    }
    
    template <typename T>
    T AccessParamValue(ParamType paramType, const ParamValue &value)
    {
        switch (paramType)
        {
            case ParamType::TAHardwareBufferConstPointer:
                return GetParamVal<ParamType::TAHardwareBufferConstPointer, T>(value);
            case ParamType::TAlphaTestFunc:
                return GetParamVal<ParamType::TAlphaTestFunc, T>(value);
            case ParamType::TBufferBinding:
                return GetParamVal<ParamType::TBufferBinding, T>(value);
            case ParamType::TBufferID:
                return GetParamVal<ParamType::TBufferID, T>(value);
            case ParamType::TBufferIDConstPointer:
                return GetParamVal<ParamType::TBufferIDConstPointer, T>(value);
            case ParamType::TBufferIDPointer:
                return GetParamVal<ParamType::TBufferIDPointer, T>(value);
            case ParamType::TBufferUsage:
                return GetParamVal<ParamType::TBufferUsage, T>(value);
            case ParamType::TClientVertexArrayType:
                return GetParamVal<ParamType::TClientVertexArrayType, T>(value);
            case ParamType::TClipDepthMode:
                return GetParamVal<ParamType::TClipDepthMode, T>(value);
            case ParamType::TClipOrigin:
                return GetParamVal<ParamType::TClipOrigin, T>(value);
            case ParamType::TCompositorTiming:
                return GetParamVal<ParamType::TCompositorTiming, T>(value);
            case ParamType::TContextID:
                return GetParamVal<ParamType::TContextID, T>(value);
            case ParamType::TCullFaceMode:
                return GetParamVal<ParamType::TCullFaceMode, T>(value);
            case ParamType::TDrawElementsType:
                return GetParamVal<ParamType::TDrawElementsType, T>(value);
            case ParamType::TEGLAttribConstPointer:
                return GetParamVal<ParamType::TEGLAttribConstPointer, T>(value);
            case ParamType::TEGLAttribKHRPointer:
                return GetParamVal<ParamType::TEGLAttribKHRPointer, T>(value);
            case ParamType::TEGLAttribPointer:
                return GetParamVal<ParamType::TEGLAttribPointer, T>(value);
            case ParamType::TEGLBoolean:
                return GetParamVal<ParamType::TEGLBoolean, T>(value);
            case ParamType::TEGLBooleanPointer:
                return GetParamVal<ParamType::TEGLBooleanPointer, T>(value);
            case ParamType::TEGLClientBuffer:
                return GetParamVal<ParamType::TEGLClientBuffer, T>(value);
            case ParamType::TEGLConfigPointer:
                return GetParamVal<ParamType::TEGLConfigPointer, T>(value);
            case ParamType::TEGLContext:
                return GetParamVal<ParamType::TEGLContext, T>(value);
            case ParamType::TEGLDEBUGPROCKHR:
                return GetParamVal<ParamType::TEGLDEBUGPROCKHR, T>(value);
            case ParamType::TEGLDeviceEXT:
                return GetParamVal<ParamType::TEGLDeviceEXT, T>(value);
            case ParamType::TEGLDisplay:
                return GetParamVal<ParamType::TEGLDisplay, T>(value);
            case ParamType::TEGLFrameTokenANGLE:
                return GetParamVal<ParamType::TEGLFrameTokenANGLE, T>(value);
            case ParamType::TEGLGetBlobFuncANDROID:
                return GetParamVal<ParamType::TEGLGetBlobFuncANDROID, T>(value);
            case ParamType::TEGLImage:
                return GetParamVal<ParamType::TEGLImage, T>(value);
            case ParamType::TEGLImageKHR:
                return GetParamVal<ParamType::TEGLImageKHR, T>(value);
            case ParamType::TEGLLabelKHR:
                return GetParamVal<ParamType::TEGLLabelKHR, T>(value);
            case ParamType::TEGLNativeDisplayType:
                return GetParamVal<ParamType::TEGLNativeDisplayType, T>(value);
            case ParamType::TEGLNativePixmapType:
                return GetParamVal<ParamType::TEGLNativePixmapType, T>(value);
            case ParamType::TEGLNativeWindowType:
                return GetParamVal<ParamType::TEGLNativeWindowType, T>(value);
            case ParamType::TEGLObjectKHR:
                return GetParamVal<ParamType::TEGLObjectKHR, T>(value);
            case ParamType::TEGLSetBlobFuncANDROID:
                return GetParamVal<ParamType::TEGLSetBlobFuncANDROID, T>(value);
            case ParamType::TEGLStreamKHR:
                return GetParamVal<ParamType::TEGLStreamKHR, T>(value);
            case ParamType::TEGLSurface:
                return GetParamVal<ParamType::TEGLSurface, T>(value);
            case ParamType::TEGLSync:
                return GetParamVal<ParamType::TEGLSync, T>(value);
            case ParamType::TEGLSyncKHR:
                return GetParamVal<ParamType::TEGLSyncKHR, T>(value);
            case ParamType::TEGLTime:
                return GetParamVal<ParamType::TEGLTime, T>(value);
            case ParamType::TEGLTimeKHR:
                return GetParamVal<ParamType::TEGLTimeKHR, T>(value);
            case ParamType::TEGLenum:
                return GetParamVal<ParamType::TEGLenum, T>(value);
            case ParamType::TEGLint:
                return GetParamVal<ParamType::TEGLint, T>(value);
            case ParamType::TEGLintConstPointer:
                return GetParamVal<ParamType::TEGLintConstPointer, T>(value);
            case ParamType::TEGLintPointer:
                return GetParamVal<ParamType::TEGLintPointer, T>(value);
            case ParamType::TEGLnsecsANDROID:
                return GetParamVal<ParamType::TEGLnsecsANDROID, T>(value);
            case ParamType::TEGLnsecsANDROIDPointer:
                return GetParamVal<ParamType::TEGLnsecsANDROIDPointer, T>(value);
            case ParamType::TEGLuint64KHR:
                return GetParamVal<ParamType::TEGLuint64KHR, T>(value);
            case ParamType::TEGLuint64KHRPointer:
                return GetParamVal<ParamType::TEGLuint64KHRPointer, T>(value);
            case ParamType::TFenceNVID:
                return GetParamVal<ParamType::TFenceNVID, T>(value);
            case ParamType::TFenceNVIDConstPointer:
                return GetParamVal<ParamType::TFenceNVIDConstPointer, T>(value);
            case ParamType::TFenceNVIDPointer:
                return GetParamVal<ParamType::TFenceNVIDPointer, T>(value);
            case ParamType::TFramebufferID:
                return GetParamVal<ParamType::TFramebufferID, T>(value);
            case ParamType::TFramebufferIDConstPointer:
                return GetParamVal<ParamType::TFramebufferIDConstPointer, T>(value);
            case ParamType::TFramebufferIDPointer:
                return GetParamVal<ParamType::TFramebufferIDPointer, T>(value);
            case ParamType::TGLDEBUGPROC:
                return GetParamVal<ParamType::TGLDEBUGPROC, T>(value);
            case ParamType::TGLDEBUGPROCKHR:
                return GetParamVal<ParamType::TGLDEBUGPROCKHR, T>(value);
            case ParamType::TGLbitfield:
                return GetParamVal<ParamType::TGLbitfield, T>(value);
            case ParamType::TGLboolean:
                return GetParamVal<ParamType::TGLboolean, T>(value);
            case ParamType::TGLbooleanConstPointer:
                return GetParamVal<ParamType::TGLbooleanConstPointer, T>(value);
            case ParamType::TGLbooleanPointer:
                return GetParamVal<ParamType::TGLbooleanPointer, T>(value);
            case ParamType::TGLbyte:
                return GetParamVal<ParamType::TGLbyte, T>(value);
            case ParamType::TGLbyteConstPointer:
                return GetParamVal<ParamType::TGLbyteConstPointer, T>(value);
            case ParamType::TGLcharConstPointer:
                return GetParamVal<ParamType::TGLcharConstPointer, T>(value);
            case ParamType::TGLcharConstPointerPointer:
                return GetParamVal<ParamType::TGLcharConstPointerPointer, T>(value);
            case ParamType::TGLcharPointer:
                return GetParamVal<ParamType::TGLcharPointer, T>(value);
            case ParamType::TGLclampx:
                return GetParamVal<ParamType::TGLclampx, T>(value);
            case ParamType::TGLdouble:
                return GetParamVal<ParamType::TGLdouble, T>(value);
            case ParamType::TGLdoubleConstPointer:
                return GetParamVal<ParamType::TGLdoubleConstPointer, T>(value);
            case ParamType::TGLdoublePointer:
                return GetParamVal<ParamType::TGLdoublePointer, T>(value);
            case ParamType::TGLeglClientBufferEXT:
                return GetParamVal<ParamType::TGLeglClientBufferEXT, T>(value);
            case ParamType::TGLenum:
                return GetParamVal<ParamType::TGLenum, T>(value);
            case ParamType::TGLenumConstPointer:
                return GetParamVal<ParamType::TGLenumConstPointer, T>(value);
            case ParamType::TGLenumPointer:
                return GetParamVal<ParamType::TGLenumPointer, T>(value);
            case ParamType::TGLfixed:
                return GetParamVal<ParamType::TGLfixed, T>(value);
            case ParamType::TGLfixedConstPointer:
                return GetParamVal<ParamType::TGLfixedConstPointer, T>(value);
            case ParamType::TGLfixedPointer:
                return GetParamVal<ParamType::TGLfixedPointer, T>(value);
            case ParamType::TGLfloat:
                return GetParamVal<ParamType::TGLfloat, T>(value);
            case ParamType::TGLfloatConstPointer:
                return GetParamVal<ParamType::TGLfloatConstPointer, T>(value);
            case ParamType::TGLfloatPointer:
                return GetParamVal<ParamType::TGLfloatPointer, T>(value);
            case ParamType::TGLint:
                return GetParamVal<ParamType::TGLint, T>(value);
            case ParamType::TGLint64:
                return GetParamVal<ParamType::TGLint64, T>(value);
            case ParamType::TGLint64Pointer:
                return GetParamVal<ParamType::TGLint64Pointer, T>(value);
            case ParamType::TGLintConstPointer:
                return GetParamVal<ParamType::TGLintConstPointer, T>(value);
            case ParamType::TGLintPointer:
                return GetParamVal<ParamType::TGLintPointer, T>(value);
            case ParamType::TGLintptr:
                return GetParamVal<ParamType::TGLintptr, T>(value);
            case ParamType::TGLintptrConstPointer:
                return GetParamVal<ParamType::TGLintptrConstPointer, T>(value);
            case ParamType::TGLshort:
                return GetParamVal<ParamType::TGLshort, T>(value);
            case ParamType::TGLshortConstPointer:
                return GetParamVal<ParamType::TGLshortConstPointer, T>(value);
            case ParamType::TGLsizei:
                return GetParamVal<ParamType::TGLsizei, T>(value);
            case ParamType::TGLsizeiConstPointer:
                return GetParamVal<ParamType::TGLsizeiConstPointer, T>(value);
            case ParamType::TGLsizeiPointer:
                return GetParamVal<ParamType::TGLsizeiPointer, T>(value);
            case ParamType::TGLsizeiptr:
                return GetParamVal<ParamType::TGLsizeiptr, T>(value);
            case ParamType::TGLsizeiptrConstPointer:
                return GetParamVal<ParamType::TGLsizeiptrConstPointer, T>(value);
            case ParamType::TGLsync:
                return GetParamVal<ParamType::TGLsync, T>(value);
            case ParamType::TGLubyte:
                return GetParamVal<ParamType::TGLubyte, T>(value);
            case ParamType::TGLubyteConstPointer:
                return GetParamVal<ParamType::TGLubyteConstPointer, T>(value);
            case ParamType::TGLubytePointer:
                return GetParamVal<ParamType::TGLubytePointer, T>(value);
            case ParamType::TGLuint:
                return GetParamVal<ParamType::TGLuint, T>(value);
            case ParamType::TGLuint64:
                return GetParamVal<ParamType::TGLuint64, T>(value);
            case ParamType::TGLuint64ConstPointer:
                return GetParamVal<ParamType::TGLuint64ConstPointer, T>(value);
            case ParamType::TGLuint64Pointer:
                return GetParamVal<ParamType::TGLuint64Pointer, T>(value);
            case ParamType::TGLuintConstPointer:
                return GetParamVal<ParamType::TGLuintConstPointer, T>(value);
            case ParamType::TGLuintPointer:
                return GetParamVal<ParamType::TGLuintPointer, T>(value);
            case ParamType::TGLushort:
                return GetParamVal<ParamType::TGLushort, T>(value);
            case ParamType::TGLushortConstPointer:
                return GetParamVal<ParamType::TGLushortConstPointer, T>(value);
            case ParamType::TGLushortPointer:
                return GetParamVal<ParamType::TGLushortPointer, T>(value);
            case ParamType::TGraphicsResetStatus:
                return GetParamVal<ParamType::TGraphicsResetStatus, T>(value);
            case ParamType::THandleType:
                return GetParamVal<ParamType::THandleType, T>(value);
            case ParamType::TImageID:
                return GetParamVal<ParamType::TImageID, T>(value);
            case ParamType::TLightParameter:
                return GetParamVal<ParamType::TLightParameter, T>(value);
            case ParamType::TLogicalOperation:
                return GetParamVal<ParamType::TLogicalOperation, T>(value);
            case ParamType::TMaterialParameter:
                return GetParamVal<ParamType::TMaterialParameter, T>(value);
            case ParamType::TMatrixType:
                return GetParamVal<ParamType::TMatrixType, T>(value);
            case ParamType::TMemoryObjectID:
                return GetParamVal<ParamType::TMemoryObjectID, T>(value);
            case ParamType::TMemoryObjectIDConstPointer:
                return GetParamVal<ParamType::TMemoryObjectIDConstPointer, T>(value);
            case ParamType::TMemoryObjectIDPointer:
                return GetParamVal<ParamType::TMemoryObjectIDPointer, T>(value);
            case ParamType::TObjectType:
                return GetParamVal<ParamType::TObjectType, T>(value);
            case ParamType::TPointParameter:
                return GetParamVal<ParamType::TPointParameter, T>(value);
            case ParamType::TPolygonMode:
                return GetParamVal<ParamType::TPolygonMode, T>(value);
            case ParamType::TPrimitiveMode:
                return GetParamVal<ParamType::TPrimitiveMode, T>(value);
            case ParamType::TProgramPipelineID:
                return GetParamVal<ParamType::TProgramPipelineID, T>(value);
            case ParamType::TProgramPipelineIDConstPointer:
                return GetParamVal<ParamType::TProgramPipelineIDConstPointer, T>(value);
            case ParamType::TProgramPipelineIDPointer:
                return GetParamVal<ParamType::TProgramPipelineIDPointer, T>(value);
            case ParamType::TProvokingVertexConvention:
                return GetParamVal<ParamType::TProvokingVertexConvention, T>(value);
            case ParamType::TQueryID:
                return GetParamVal<ParamType::TQueryID, T>(value);
            case ParamType::TQueryIDConstPointer:
                return GetParamVal<ParamType::TQueryIDConstPointer, T>(value);
            case ParamType::TQueryIDPointer:
                return GetParamVal<ParamType::TQueryIDPointer, T>(value);
            case ParamType::TQueryType:
                return GetParamVal<ParamType::TQueryType, T>(value);
            case ParamType::TRenderbufferID:
                return GetParamVal<ParamType::TRenderbufferID, T>(value);
            case ParamType::TRenderbufferIDConstPointer:
                return GetParamVal<ParamType::TRenderbufferIDConstPointer, T>(value);
            case ParamType::TRenderbufferIDPointer:
                return GetParamVal<ParamType::TRenderbufferIDPointer, T>(value);
            case ParamType::TSamplerID:
                return GetParamVal<ParamType::TSamplerID, T>(value);
            case ParamType::TSamplerIDConstPointer:
                return GetParamVal<ParamType::TSamplerIDConstPointer, T>(value);
            case ParamType::TSamplerIDPointer:
                return GetParamVal<ParamType::TSamplerIDPointer, T>(value);
            case ParamType::TSemaphoreID:
                return GetParamVal<ParamType::TSemaphoreID, T>(value);
            case ParamType::TSemaphoreIDConstPointer:
                return GetParamVal<ParamType::TSemaphoreIDConstPointer, T>(value);
            case ParamType::TSemaphoreIDPointer:
                return GetParamVal<ParamType::TSemaphoreIDPointer, T>(value);
            case ParamType::TShaderProgramID:
                return GetParamVal<ParamType::TShaderProgramID, T>(value);
            case ParamType::TShaderProgramIDConstPointer:
                return GetParamVal<ParamType::TShaderProgramIDConstPointer, T>(value);
            case ParamType::TShaderProgramIDPointer:
                return GetParamVal<ParamType::TShaderProgramIDPointer, T>(value);
            case ParamType::TShaderType:
                return GetParamVal<ParamType::TShaderType, T>(value);
            case ParamType::TShadingModel:
                return GetParamVal<ParamType::TShadingModel, T>(value);
            case ParamType::TSurfaceID:
                return GetParamVal<ParamType::TSurfaceID, T>(value);
            case ParamType::TSyncID:
                return GetParamVal<ParamType::TSyncID, T>(value);
            case ParamType::TTextureEnvParameter:
                return GetParamVal<ParamType::TTextureEnvParameter, T>(value);
            case ParamType::TTextureEnvTarget:
                return GetParamVal<ParamType::TTextureEnvTarget, T>(value);
            case ParamType::TTextureID:
                return GetParamVal<ParamType::TTextureID, T>(value);
            case ParamType::TTextureIDConstPointer:
                return GetParamVal<ParamType::TTextureIDConstPointer, T>(value);
            case ParamType::TTextureIDPointer:
                return GetParamVal<ParamType::TTextureIDPointer, T>(value);
            case ParamType::TTextureTarget:
                return GetParamVal<ParamType::TTextureTarget, T>(value);
            case ParamType::TTextureType:
                return GetParamVal<ParamType::TTextureType, T>(value);
            case ParamType::TTimestamp:
                return GetParamVal<ParamType::TTimestamp, T>(value);
            case ParamType::TTransformFeedbackID:
                return GetParamVal<ParamType::TTransformFeedbackID, T>(value);
            case ParamType::TTransformFeedbackIDConstPointer:
                return GetParamVal<ParamType::TTransformFeedbackIDConstPointer, T>(value);
            case ParamType::TTransformFeedbackIDPointer:
                return GetParamVal<ParamType::TTransformFeedbackIDPointer, T>(value);
            case ParamType::TUniformBlockIndex:
                return GetParamVal<ParamType::TUniformBlockIndex, T>(value);
            case ParamType::TUniformLocation:
                return GetParamVal<ParamType::TUniformLocation, T>(value);
            case ParamType::TVertexArrayID:
                return GetParamVal<ParamType::TVertexArrayID, T>(value);
            case ParamType::TVertexArrayIDConstPointer:
                return GetParamVal<ParamType::TVertexArrayIDConstPointer, T>(value);
            case ParamType::TVertexArrayIDPointer:
                return GetParamVal<ParamType::TVertexArrayIDPointer, T>(value);
            case ParamType::TVertexAttribType:
                return GetParamVal<ParamType::TVertexAttribType, T>(value);
            case ParamType::TcharConstPointer:
                return GetParamVal<ParamType::TcharConstPointer, T>(value);
            case ParamType::Tegl_ConfigPointer:
                return GetParamVal<ParamType::Tegl_ConfigPointer, T>(value);
            case ParamType::Tegl_DevicePointer:
                return GetParamVal<ParamType::Tegl_DevicePointer, T>(value);
            case ParamType::Tegl_DisplayPointer:
                return GetParamVal<ParamType::Tegl_DisplayPointer, T>(value);
            case ParamType::Tegl_StreamPointer:
                return GetParamVal<ParamType::Tegl_StreamPointer, T>(value);
            case ParamType::Tegl_SyncID:
                return GetParamVal<ParamType::Tegl_SyncID, T>(value);
            case ParamType::TvoidConstPointer:
                return GetParamVal<ParamType::TvoidConstPointer, T>(value);
            case ParamType::TvoidConstPointerPointer:
                return GetParamVal<ParamType::TvoidConstPointerPointer, T>(value);
            case ParamType::TvoidPointer:
                return GetParamVal<ParamType::TvoidPointer, T>(value);
            case ParamType::TvoidPointerPointer:
                return GetParamVal<ParamType::TvoidPointerPointer, T>(value);
        }
        UNREACHABLE();
        return T();
    }
    
    template <ParamType PType, typename T>
    void SetParamVal(T valueIn, ParamValue *valueOut);
    
    template <>
    inline void SetParamVal<ParamType::TAHardwareBufferConstPointer>(const AHardwareBuffer *valueIn,
                                                                     ParamValue *valueOut)
    {
        valueOut->AHardwareBufferConstPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TAlphaTestFunc>(gl::AlphaTestFunc valueIn, ParamValue *valueOut)
    {
        valueOut->AlphaTestFuncVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TBufferBinding>(gl::BufferBinding valueIn, ParamValue *valueOut)
    {
        valueOut->BufferBindingVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TBufferID>(gl::BufferID valueIn, ParamValue *valueOut)
    {
        valueOut->BufferIDVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TBufferIDConstPointer>(const gl::BufferID *valueIn,
                                                              ParamValue *valueOut)
    {
        valueOut->BufferIDConstPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TBufferIDPointer>(gl::BufferID *valueIn, ParamValue *valueOut)
    {
        valueOut->BufferIDPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TBufferUsage>(gl::BufferUsage valueIn, ParamValue *valueOut)
    {
        valueOut->BufferUsageVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TClientVertexArrayType>(gl::ClientVertexArrayType valueIn,
                                                               ParamValue *valueOut)
    {
        valueOut->ClientVertexArrayTypeVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TClipDepthMode>(gl::ClipDepthMode valueIn, ParamValue *valueOut)
    {
        valueOut->ClipDepthModeVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TClipOrigin>(gl::ClipOrigin valueIn, ParamValue *valueOut)
    {
        valueOut->ClipOriginVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TCompositorTiming>(egl::CompositorTiming valueIn,
                                                          ParamValue *valueOut)
    {
        valueOut->CompositorTimingVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TContextID>(gl::ContextID valueIn, ParamValue *valueOut)
    {
        valueOut->ContextIDVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TCullFaceMode>(gl::CullFaceMode valueIn, ParamValue *valueOut)
    {
        valueOut->CullFaceModeVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TDrawElementsType>(gl::DrawElementsType valueIn,
                                                          ParamValue *valueOut)
    {
        valueOut->DrawElementsTypeVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TEGLAttribConstPointer>(const EGLAttrib *valueIn,
                                                               ParamValue *valueOut)
    {
        valueOut->EGLAttribConstPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TEGLAttribKHRPointer>(EGLAttribKHR *valueIn,
                                                             ParamValue *valueOut)
    {
        valueOut->EGLAttribKHRPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TEGLAttribPointer>(EGLAttrib *valueIn, ParamValue *valueOut)
    {
        valueOut->EGLAttribPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TEGLBoolean>(EGLBoolean valueIn, ParamValue *valueOut)
    {
        valueOut->EGLBooleanVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TEGLBooleanPointer>(EGLBoolean *valueIn, ParamValue *valueOut)
    {
        valueOut->EGLBooleanPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TEGLClientBuffer>(EGLClientBuffer valueIn, ParamValue *valueOut)
    {
        valueOut->EGLClientBufferVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TEGLConfigPointer>(EGLConfig *valueIn, ParamValue *valueOut)
    {
        valueOut->EGLConfigPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TEGLContext>(EGLContext valueIn, ParamValue *valueOut)
    {
        valueOut->EGLContextVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TEGLDEBUGPROCKHR>(EGLDEBUGPROCKHR valueIn, ParamValue *valueOut)
    {
        valueOut->EGLDEBUGPROCKHRVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TEGLDeviceEXT>(EGLDeviceEXT valueIn, ParamValue *valueOut)
    {
        valueOut->EGLDeviceEXTVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TEGLDisplay>(EGLDisplay valueIn, ParamValue *valueOut)
    {
        valueOut->EGLDisplayVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TEGLFrameTokenANGLE>(EGLFrameTokenANGLE valueIn,
                                                            ParamValue *valueOut)
    {
        valueOut->EGLFrameTokenANGLEVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TEGLGetBlobFuncANDROID>(EGLGetBlobFuncANDROID valueIn,
                                                               ParamValue *valueOut)
    {
        valueOut->EGLGetBlobFuncANDROIDVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TEGLImage>(EGLImage valueIn, ParamValue *valueOut)
    {
        valueOut->EGLImageVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TEGLImageKHR>(EGLImageKHR valueIn, ParamValue *valueOut)
    {
        valueOut->EGLImageKHRVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TEGLLabelKHR>(EGLLabelKHR valueIn, ParamValue *valueOut)
    {
        valueOut->EGLLabelKHRVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TEGLNativeDisplayType>(EGLNativeDisplayType valueIn,
                                                              ParamValue *valueOut)
    {
        valueOut->EGLNativeDisplayTypeVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TEGLNativePixmapType>(EGLNativePixmapType valueIn,
                                                             ParamValue *valueOut)
    {
        valueOut->EGLNativePixmapTypeVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TEGLNativeWindowType>(EGLNativeWindowType valueIn,
                                                             ParamValue *valueOut)
    {
        valueOut->EGLNativeWindowTypeVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TEGLObjectKHR>(EGLObjectKHR valueIn, ParamValue *valueOut)
    {
        valueOut->EGLObjectKHRVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TEGLSetBlobFuncANDROID>(EGLSetBlobFuncANDROID valueIn,
                                                               ParamValue *valueOut)
    {
        valueOut->EGLSetBlobFuncANDROIDVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TEGLStreamKHR>(EGLStreamKHR valueIn, ParamValue *valueOut)
    {
        valueOut->EGLStreamKHRVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TEGLSurface>(EGLSurface valueIn, ParamValue *valueOut)
    {
        valueOut->EGLSurfaceVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TEGLSync>(EGLSync valueIn, ParamValue *valueOut)
    {
        valueOut->EGLSyncVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TEGLSyncKHR>(EGLSyncKHR valueIn, ParamValue *valueOut)
    {
        valueOut->EGLSyncKHRVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TEGLTime>(EGLTime valueIn, ParamValue *valueOut)
    {
        valueOut->EGLTimeVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TEGLTimeKHR>(EGLTimeKHR valueIn, ParamValue *valueOut)
    {
        valueOut->EGLTimeKHRVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TEGLenum>(EGLenum valueIn, ParamValue *valueOut)
    {
        valueOut->EGLenumVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TEGLint>(EGLint valueIn, ParamValue *valueOut)
    {
        valueOut->EGLintVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TEGLintConstPointer>(const EGLint *valueIn, ParamValue *valueOut)
    {
        valueOut->EGLintConstPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TEGLintPointer>(EGLint *valueIn, ParamValue *valueOut)
    {
        valueOut->EGLintPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TEGLnsecsANDROID>(EGLnsecsANDROID valueIn, ParamValue *valueOut)
    {
        valueOut->EGLnsecsANDROIDVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TEGLnsecsANDROIDPointer>(EGLnsecsANDROID *valueIn,
                                                                ParamValue *valueOut)
    {
        valueOut->EGLnsecsANDROIDPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TEGLuint64KHR>(EGLuint64KHR valueIn, ParamValue *valueOut)
    {
        valueOut->EGLuint64KHRVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TEGLuint64KHRPointer>(EGLuint64KHR *valueIn,
                                                             ParamValue *valueOut)
    {
        valueOut->EGLuint64KHRPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TFenceNVID>(gl::FenceNVID valueIn, ParamValue *valueOut)
    {
        valueOut->FenceNVIDVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TFenceNVIDConstPointer>(const gl::FenceNVID *valueIn,
                                                               ParamValue *valueOut)
    {
        valueOut->FenceNVIDConstPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TFenceNVIDPointer>(gl::FenceNVID *valueIn, ParamValue *valueOut)
    {
        valueOut->FenceNVIDPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TFramebufferID>(gl::FramebufferID valueIn, ParamValue *valueOut)
    {
        valueOut->FramebufferIDVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TFramebufferIDConstPointer>(const gl::FramebufferID *valueIn,
                                                                   ParamValue *valueOut)
    {
        valueOut->FramebufferIDConstPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TFramebufferIDPointer>(gl::FramebufferID *valueIn,
                                                              ParamValue *valueOut)
    {
        valueOut->FramebufferIDPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLDEBUGPROC>(GLDEBUGPROC valueIn, ParamValue *valueOut)
    {
        valueOut->GLDEBUGPROCVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLDEBUGPROCKHR>(GLDEBUGPROCKHR valueIn, ParamValue *valueOut)
    {
        valueOut->GLDEBUGPROCKHRVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLbitfield>(GLbitfield valueIn, ParamValue *valueOut)
    {
        valueOut->GLbitfieldVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLboolean>(GLboolean valueIn, ParamValue *valueOut)
    {
        valueOut->GLbooleanVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLbooleanConstPointer>(const GLboolean *valueIn,
                                                               ParamValue *valueOut)
    {
        valueOut->GLbooleanConstPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLbooleanPointer>(GLboolean *valueIn, ParamValue *valueOut)
    {
        valueOut->GLbooleanPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLbyte>(GLbyte valueIn, ParamValue *valueOut)
    {
        valueOut->GLbyteVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLbyteConstPointer>(const GLbyte *valueIn, ParamValue *valueOut)
    {
        valueOut->GLbyteConstPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLcharConstPointer>(const GLchar *valueIn, ParamValue *valueOut)
    {
        valueOut->GLcharConstPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLcharConstPointerPointer>(const GLchar *const *valueIn,
                                                                   ParamValue *valueOut)
    {
        valueOut->GLcharConstPointerPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLcharPointer>(GLchar *valueIn, ParamValue *valueOut)
    {
        valueOut->GLcharPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLclampx>(GLclampx valueIn, ParamValue *valueOut)
    {
        valueOut->GLclampxVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLdouble>(GLdouble valueIn, ParamValue *valueOut)
    {
        valueOut->GLdoubleVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLdoubleConstPointer>(const GLdouble *valueIn,
                                                              ParamValue *valueOut)
    {
        valueOut->GLdoubleConstPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLdoublePointer>(GLdouble *valueIn, ParamValue *valueOut)
    {
        valueOut->GLdoublePointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLeglClientBufferEXT>(GLeglClientBufferEXT valueIn,
                                                              ParamValue *valueOut)
    {
        valueOut->GLeglClientBufferEXTVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLenum>(GLenum valueIn, ParamValue *valueOut)
    {
        valueOut->GLenumVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLenumConstPointer>(const GLenum *valueIn, ParamValue *valueOut)
    {
        valueOut->GLenumConstPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLenumPointer>(GLenum *valueIn, ParamValue *valueOut)
    {
        valueOut->GLenumPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLfixed>(GLfixed valueIn, ParamValue *valueOut)
    {
        valueOut->GLfixedVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLfixedConstPointer>(const GLfixed *valueIn,
                                                             ParamValue *valueOut)
    {
        valueOut->GLfixedConstPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLfixedPointer>(GLfixed *valueIn, ParamValue *valueOut)
    {
        valueOut->GLfixedPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLfloat>(GLfloat valueIn, ParamValue *valueOut)
    {
        valueOut->GLfloatVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLfloatConstPointer>(const GLfloat *valueIn,
                                                             ParamValue *valueOut)
    {
        valueOut->GLfloatConstPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLfloatPointer>(GLfloat *valueIn, ParamValue *valueOut)
    {
        valueOut->GLfloatPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLint>(GLint valueIn, ParamValue *valueOut)
    {
        valueOut->GLintVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLint64>(GLint64 valueIn, ParamValue *valueOut)
    {
        valueOut->GLint64Val = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLint64Pointer>(GLint64 *valueIn, ParamValue *valueOut)
    {
        valueOut->GLint64PointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLintConstPointer>(const GLint *valueIn, ParamValue *valueOut)
    {
        valueOut->GLintConstPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLintPointer>(GLint *valueIn, ParamValue *valueOut)
    {
        valueOut->GLintPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLintptr>(GLintptr valueIn, ParamValue *valueOut)
    {
        valueOut->GLintptrVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLintptrConstPointer>(const GLintptr *valueIn,
                                                              ParamValue *valueOut)
    {
        valueOut->GLintptrConstPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLshort>(GLshort valueIn, ParamValue *valueOut)
    {
        valueOut->GLshortVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLshortConstPointer>(const GLshort *valueIn,
                                                             ParamValue *valueOut)
    {
        valueOut->GLshortConstPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLsizei>(GLsizei valueIn, ParamValue *valueOut)
    {
        valueOut->GLsizeiVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLsizeiConstPointer>(const GLsizei *valueIn,
                                                             ParamValue *valueOut)
    {
        valueOut->GLsizeiConstPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLsizeiPointer>(GLsizei *valueIn, ParamValue *valueOut)
    {
        valueOut->GLsizeiPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLsizeiptr>(GLsizeiptr valueIn, ParamValue *valueOut)
    {
        valueOut->GLsizeiptrVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLsizeiptrConstPointer>(const GLsizeiptr *valueIn,
                                                                ParamValue *valueOut)
    {
        valueOut->GLsizeiptrConstPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLsync>(GLsync valueIn, ParamValue *valueOut)
    {
        valueOut->GLsyncVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLubyte>(GLubyte valueIn, ParamValue *valueOut)
    {
        valueOut->GLubyteVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLubyteConstPointer>(const GLubyte *valueIn,
                                                             ParamValue *valueOut)
    {
        valueOut->GLubyteConstPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLubytePointer>(GLubyte *valueIn, ParamValue *valueOut)
    {
        valueOut->GLubytePointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLuint>(GLuint valueIn, ParamValue *valueOut)
    {
        valueOut->GLuintVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLuint64>(GLuint64 valueIn, ParamValue *valueOut)
    {
        valueOut->GLuint64Val = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLuint64ConstPointer>(const GLuint64 *valueIn,
                                                              ParamValue *valueOut)
    {
        valueOut->GLuint64ConstPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLuint64Pointer>(GLuint64 *valueIn, ParamValue *valueOut)
    {
        valueOut->GLuint64PointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLuintConstPointer>(const GLuint *valueIn, ParamValue *valueOut)
    {
        valueOut->GLuintConstPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLuintPointer>(GLuint *valueIn, ParamValue *valueOut)
    {
        valueOut->GLuintPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLushort>(GLushort valueIn, ParamValue *valueOut)
    {
        valueOut->GLushortVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLushortConstPointer>(const GLushort *valueIn,
                                                              ParamValue *valueOut)
    {
        valueOut->GLushortConstPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGLushortPointer>(GLushort *valueIn, ParamValue *valueOut)
    {
        valueOut->GLushortPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TGraphicsResetStatus>(gl::GraphicsResetStatus valueIn,
                                                             ParamValue *valueOut)
    {
        valueOut->GraphicsResetStatusVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::THandleType>(gl::HandleType valueIn, ParamValue *valueOut)
    {
        valueOut->HandleTypeVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TImageID>(egl::ImageID valueIn, ParamValue *valueOut)
    {
        valueOut->ImageIDVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TLightParameter>(gl::LightParameter valueIn,
                                                        ParamValue *valueOut)
    {
        valueOut->LightParameterVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TLogicalOperation>(gl::LogicalOperation valueIn,
                                                          ParamValue *valueOut)
    {
        valueOut->LogicalOperationVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TMaterialParameter>(gl::MaterialParameter valueIn,
                                                           ParamValue *valueOut)
    {
        valueOut->MaterialParameterVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TMatrixType>(gl::MatrixType valueIn, ParamValue *valueOut)
    {
        valueOut->MatrixTypeVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TMemoryObjectID>(gl::MemoryObjectID valueIn,
                                                        ParamValue *valueOut)
    {
        valueOut->MemoryObjectIDVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TMemoryObjectIDConstPointer>(const gl::MemoryObjectID *valueIn,
                                                                    ParamValue *valueOut)
    {
        valueOut->MemoryObjectIDConstPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TMemoryObjectIDPointer>(gl::MemoryObjectID *valueIn,
                                                               ParamValue *valueOut)
    {
        valueOut->MemoryObjectIDPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TObjectType>(egl::ObjectType valueIn, ParamValue *valueOut)
    {
        valueOut->ObjectTypeVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TPointParameter>(gl::PointParameter valueIn,
                                                        ParamValue *valueOut)
    {
        valueOut->PointParameterVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TPolygonMode>(gl::PolygonMode valueIn, ParamValue *valueOut)
    {
        valueOut->PolygonModeVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TPrimitiveMode>(gl::PrimitiveMode valueIn, ParamValue *valueOut)
    {
        valueOut->PrimitiveModeVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TProgramPipelineID>(gl::ProgramPipelineID valueIn,
                                                           ParamValue *valueOut)
    {
        valueOut->ProgramPipelineIDVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TProgramPipelineIDConstPointer>(
        const gl::ProgramPipelineID *valueIn,
        ParamValue *valueOut)
    {
        valueOut->ProgramPipelineIDConstPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TProgramPipelineIDPointer>(gl::ProgramPipelineID *valueIn,
                                                                  ParamValue *valueOut)
    {
        valueOut->ProgramPipelineIDPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TProvokingVertexConvention>(
        gl::ProvokingVertexConvention valueIn,
        ParamValue *valueOut)
    {
        valueOut->ProvokingVertexConventionVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TQueryID>(gl::QueryID valueIn, ParamValue *valueOut)
    {
        valueOut->QueryIDVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TQueryIDConstPointer>(const gl::QueryID *valueIn,
                                                             ParamValue *valueOut)
    {
        valueOut->QueryIDConstPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TQueryIDPointer>(gl::QueryID *valueIn, ParamValue *valueOut)
    {
        valueOut->QueryIDPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TQueryType>(gl::QueryType valueIn, ParamValue *valueOut)
    {
        valueOut->QueryTypeVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TRenderbufferID>(gl::RenderbufferID valueIn,
                                                        ParamValue *valueOut)
    {
        valueOut->RenderbufferIDVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TRenderbufferIDConstPointer>(const gl::RenderbufferID *valueIn,
                                                                    ParamValue *valueOut)
    {
        valueOut->RenderbufferIDConstPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TRenderbufferIDPointer>(gl::RenderbufferID *valueIn,
                                                               ParamValue *valueOut)
    {
        valueOut->RenderbufferIDPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TSamplerID>(gl::SamplerID valueIn, ParamValue *valueOut)
    {
        valueOut->SamplerIDVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TSamplerIDConstPointer>(const gl::SamplerID *valueIn,
                                                               ParamValue *valueOut)
    {
        valueOut->SamplerIDConstPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TSamplerIDPointer>(gl::SamplerID *valueIn, ParamValue *valueOut)
    {
        valueOut->SamplerIDPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TSemaphoreID>(gl::SemaphoreID valueIn, ParamValue *valueOut)
    {
        valueOut->SemaphoreIDVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TSemaphoreIDConstPointer>(const gl::SemaphoreID *valueIn,
                                                                 ParamValue *valueOut)
    {
        valueOut->SemaphoreIDConstPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TSemaphoreIDPointer>(gl::SemaphoreID *valueIn,
                                                            ParamValue *valueOut)
    {
        valueOut->SemaphoreIDPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TShaderProgramID>(gl::ShaderProgramID valueIn,
                                                         ParamValue *valueOut)
    {
        valueOut->ShaderProgramIDVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TShaderProgramIDConstPointer>(const gl::ShaderProgramID *valueIn,
                                                                     ParamValue *valueOut)
    {
        valueOut->ShaderProgramIDConstPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TShaderProgramIDPointer>(gl::ShaderProgramID *valueIn,
                                                                ParamValue *valueOut)
    {
        valueOut->ShaderProgramIDPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TShaderType>(gl::ShaderType valueIn, ParamValue *valueOut)
    {
        valueOut->ShaderTypeVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TShadingModel>(gl::ShadingModel valueIn, ParamValue *valueOut)
    {
        valueOut->ShadingModelVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TSurfaceID>(egl::SurfaceID valueIn, ParamValue *valueOut)
    {
        valueOut->SurfaceIDVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TSyncID>(gl::SyncID valueIn, ParamValue *valueOut)
    {
        valueOut->SyncIDVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TTextureEnvParameter>(gl::TextureEnvParameter valueIn,
                                                             ParamValue *valueOut)
    {
        valueOut->TextureEnvParameterVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TTextureEnvTarget>(gl::TextureEnvTarget valueIn,
                                                          ParamValue *valueOut)
    {
        valueOut->TextureEnvTargetVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TTextureID>(gl::TextureID valueIn, ParamValue *valueOut)
    {
        valueOut->TextureIDVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TTextureIDConstPointer>(const gl::TextureID *valueIn,
                                                               ParamValue *valueOut)
    {
        valueOut->TextureIDConstPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TTextureIDPointer>(gl::TextureID *valueIn, ParamValue *valueOut)
    {
        valueOut->TextureIDPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TTextureTarget>(gl::TextureTarget valueIn, ParamValue *valueOut)
    {
        valueOut->TextureTargetVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TTextureType>(gl::TextureType valueIn, ParamValue *valueOut)
    {
        valueOut->TextureTypeVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TTimestamp>(egl::Timestamp valueIn, ParamValue *valueOut)
    {
        valueOut->TimestampVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TTransformFeedbackID>(gl::TransformFeedbackID valueIn,
                                                             ParamValue *valueOut)
    {
        valueOut->TransformFeedbackIDVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TTransformFeedbackIDConstPointer>(
        const gl::TransformFeedbackID *valueIn,
        ParamValue *valueOut)
    {
        valueOut->TransformFeedbackIDConstPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TTransformFeedbackIDPointer>(gl::TransformFeedbackID *valueIn,
                                                                    ParamValue *valueOut)
    {
        valueOut->TransformFeedbackIDPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TUniformBlockIndex>(gl::UniformBlockIndex valueIn,
                                                           ParamValue *valueOut)
    {
        valueOut->UniformBlockIndexVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TUniformLocation>(gl::UniformLocation valueIn,
                                                         ParamValue *valueOut)
    {
        valueOut->UniformLocationVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TVertexArrayID>(gl::VertexArrayID valueIn, ParamValue *valueOut)
    {
        valueOut->VertexArrayIDVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TVertexArrayIDConstPointer>(const gl::VertexArrayID *valueIn,
                                                                   ParamValue *valueOut)
    {
        valueOut->VertexArrayIDConstPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TVertexArrayIDPointer>(gl::VertexArrayID *valueIn,
                                                              ParamValue *valueOut)
    {
        valueOut->VertexArrayIDPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TVertexAttribType>(gl::VertexAttribType valueIn,
                                                          ParamValue *valueOut)
    {
        valueOut->VertexAttribTypeVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TcharConstPointer>(const char *valueIn, ParamValue *valueOut)
    {
        valueOut->charConstPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::Tegl_ConfigPointer>(egl::Config *valueIn, ParamValue *valueOut)
    {
        valueOut->egl_ConfigPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::Tegl_DevicePointer>(egl::Device *valueIn, ParamValue *valueOut)
    {
        valueOut->egl_DevicePointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::Tegl_DisplayPointer>(egl::Display *valueIn, ParamValue *valueOut)
    {
        valueOut->egl_DisplayPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::Tegl_StreamPointer>(egl::Stream *valueIn, ParamValue *valueOut)
    {
        valueOut->egl_StreamPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::Tegl_SyncID>(egl::SyncID valueIn, ParamValue *valueOut)
    {
        valueOut->egl_SyncIDVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TvoidConstPointer>(const void *valueIn, ParamValue *valueOut)
    {
        valueOut->voidConstPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TvoidConstPointerPointer>(const void *const *valueIn,
                                                                 ParamValue *valueOut)
    {
        valueOut->voidConstPointerPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TvoidPointer>(void *valueIn, ParamValue *valueOut)
    {
        valueOut->voidPointerVal = valueIn;
    }
    
    template <>
    inline void SetParamVal<ParamType::TvoidPointerPointer>(void **valueIn, ParamValue *valueOut)
    {
        valueOut->voidPointerPointerVal = valueIn;
    }
    
    template <ParamType PType, typename T>
    void SetParamVal(T valueIn, ParamValue *valueOut)
    {
        UNREACHABLE();
    }
    
    template <typename T>
    void InitParamValue(ParamType paramType, T valueIn, ParamValue *valueOut)
    {
        switch (paramType)
        {
            case ParamType::TAHardwareBufferConstPointer:
                SetParamVal<ParamType::TAHardwareBufferConstPointer>(valueIn, valueOut);
                break;
            case ParamType::TAlphaTestFunc:
                SetParamVal<ParamType::TAlphaTestFunc>(valueIn, valueOut);
                break;
            case ParamType::TBufferBinding:
                SetParamVal<ParamType::TBufferBinding>(valueIn, valueOut);
                break;
            case ParamType::TBufferID:
                SetParamVal<ParamType::TBufferID>(valueIn, valueOut);
                break;
            case ParamType::TBufferIDConstPointer:
                SetParamVal<ParamType::TBufferIDConstPointer>(valueIn, valueOut);
                break;
            case ParamType::TBufferIDPointer:
                SetParamVal<ParamType::TBufferIDPointer>(valueIn, valueOut);
                break;
            case ParamType::TBufferUsage:
                SetParamVal<ParamType::TBufferUsage>(valueIn, valueOut);
                break;
            case ParamType::TClientVertexArrayType:
                SetParamVal<ParamType::TClientVertexArrayType>(valueIn, valueOut);
                break;
            case ParamType::TClipDepthMode:
                SetParamVal<ParamType::TClipDepthMode>(valueIn, valueOut);
                break;
            case ParamType::TClipOrigin:
                SetParamVal<ParamType::TClipOrigin>(valueIn, valueOut);
                break;
            case ParamType::TCompositorTiming:
                SetParamVal<ParamType::TCompositorTiming>(valueIn, valueOut);
                break;
            case ParamType::TContextID:
                SetParamVal<ParamType::TContextID>(valueIn, valueOut);
                break;
            case ParamType::TCullFaceMode:
                SetParamVal<ParamType::TCullFaceMode>(valueIn, valueOut);
                break;
            case ParamType::TDrawElementsType:
                SetParamVal<ParamType::TDrawElementsType>(valueIn, valueOut);
                break;
            case ParamType::TEGLAttribConstPointer:
                SetParamVal<ParamType::TEGLAttribConstPointer>(valueIn, valueOut);
                break;
            case ParamType::TEGLAttribKHRPointer:
                SetParamVal<ParamType::TEGLAttribKHRPointer>(valueIn, valueOut);
                break;
            case ParamType::TEGLAttribPointer:
                SetParamVal<ParamType::TEGLAttribPointer>(valueIn, valueOut);
                break;
            case ParamType::TEGLBoolean:
                SetParamVal<ParamType::TEGLBoolean>(valueIn, valueOut);
                break;
            case ParamType::TEGLBooleanPointer:
                SetParamVal<ParamType::TEGLBooleanPointer>(valueIn, valueOut);
                break;
            case ParamType::TEGLClientBuffer:
                SetParamVal<ParamType::TEGLClientBuffer>(valueIn, valueOut);
                break;
            case ParamType::TEGLConfigPointer:
                SetParamVal<ParamType::TEGLConfigPointer>(valueIn, valueOut);
                break;
            case ParamType::TEGLContext:
                SetParamVal<ParamType::TEGLContext>(valueIn, valueOut);
                break;
            case ParamType::TEGLDEBUGPROCKHR:
                SetParamVal<ParamType::TEGLDEBUGPROCKHR>(valueIn, valueOut);
                break;
            case ParamType::TEGLDeviceEXT:
                SetParamVal<ParamType::TEGLDeviceEXT>(valueIn, valueOut);
                break;
            case ParamType::TEGLDisplay:
                SetParamVal<ParamType::TEGLDisplay>(valueIn, valueOut);
                break;
            case ParamType::TEGLFrameTokenANGLE:
                SetParamVal<ParamType::TEGLFrameTokenANGLE>(valueIn, valueOut);
                break;
            case ParamType::TEGLGetBlobFuncANDROID:
                SetParamVal<ParamType::TEGLGetBlobFuncANDROID>(valueIn, valueOut);
                break;
            case ParamType::TEGLImage:
                SetParamVal<ParamType::TEGLImage>(valueIn, valueOut);
                break;
            case ParamType::TEGLImageKHR:
                SetParamVal<ParamType::TEGLImageKHR>(valueIn, valueOut);
                break;
            case ParamType::TEGLLabelKHR:
                SetParamVal<ParamType::TEGLLabelKHR>(valueIn, valueOut);
                break;
            case ParamType::TEGLNativeDisplayType:
                SetParamVal<ParamType::TEGLNativeDisplayType>(valueIn, valueOut);
                break;
            case ParamType::TEGLNativePixmapType:
                SetParamVal<ParamType::TEGLNativePixmapType>(valueIn, valueOut);
                break;
            case ParamType::TEGLNativeWindowType:
                SetParamVal<ParamType::TEGLNativeWindowType>(valueIn, valueOut);
                break;
            case ParamType::TEGLObjectKHR:
                SetParamVal<ParamType::TEGLObjectKHR>(valueIn, valueOut);
                break;
            case ParamType::TEGLSetBlobFuncANDROID:
                SetParamVal<ParamType::TEGLSetBlobFuncANDROID>(valueIn, valueOut);
                break;
            case ParamType::TEGLStreamKHR:
                SetParamVal<ParamType::TEGLStreamKHR>(valueIn, valueOut);
                break;
            case ParamType::TEGLSurface:
                SetParamVal<ParamType::TEGLSurface>(valueIn, valueOut);
                break;
            case ParamType::TEGLSync:
                SetParamVal<ParamType::TEGLSync>(valueIn, valueOut);
                break;
            case ParamType::TEGLSyncKHR:
                SetParamVal<ParamType::TEGLSyncKHR>(valueIn, valueOut);
                break;
            case ParamType::TEGLTime:
                SetParamVal<ParamType::TEGLTime>(valueIn, valueOut);
                break;
            case ParamType::TEGLTimeKHR:
                SetParamVal<ParamType::TEGLTimeKHR>(valueIn, valueOut);
                break;
            case ParamType::TEGLenum:
                SetParamVal<ParamType::TEGLenum>(valueIn, valueOut);
                break;
            case ParamType::TEGLint:
                SetParamVal<ParamType::TEGLint>(valueIn, valueOut);
                break;
            case ParamType::TEGLintConstPointer:
                SetParamVal<ParamType::TEGLintConstPointer>(valueIn, valueOut);
                break;
            case ParamType::TEGLintPointer:
                SetParamVal<ParamType::TEGLintPointer>(valueIn, valueOut);
                break;
            case ParamType::TEGLnsecsANDROID:
                SetParamVal<ParamType::TEGLnsecsANDROID>(valueIn, valueOut);
                break;
            case ParamType::TEGLnsecsANDROIDPointer:
                SetParamVal<ParamType::TEGLnsecsANDROIDPointer>(valueIn, valueOut);
                break;
            case ParamType::TEGLuint64KHR:
                SetParamVal<ParamType::TEGLuint64KHR>(valueIn, valueOut);
                break;
            case ParamType::TEGLuint64KHRPointer:
                SetParamVal<ParamType::TEGLuint64KHRPointer>(valueIn, valueOut);
                break;
            case ParamType::TFenceNVID:
                SetParamVal<ParamType::TFenceNVID>(valueIn, valueOut);
                break;
            case ParamType::TFenceNVIDConstPointer:
                SetParamVal<ParamType::TFenceNVIDConstPointer>(valueIn, valueOut);
                break;
            case ParamType::TFenceNVIDPointer:
                SetParamVal<ParamType::TFenceNVIDPointer>(valueIn, valueOut);
                break;
            case ParamType::TFramebufferID:
                SetParamVal<ParamType::TFramebufferID>(valueIn, valueOut);
                break;
            case ParamType::TFramebufferIDConstPointer:
                SetParamVal<ParamType::TFramebufferIDConstPointer>(valueIn, valueOut);
                break;
            case ParamType::TFramebufferIDPointer:
                SetParamVal<ParamType::TFramebufferIDPointer>(valueIn, valueOut);
                break;
            case ParamType::TGLDEBUGPROC:
                SetParamVal<ParamType::TGLDEBUGPROC>(valueIn, valueOut);
                break;
            case ParamType::TGLDEBUGPROCKHR:
                SetParamVal<ParamType::TGLDEBUGPROCKHR>(valueIn, valueOut);
                break;
            case ParamType::TGLbitfield:
                SetParamVal<ParamType::TGLbitfield>(valueIn, valueOut);
                break;
            case ParamType::TGLboolean:
                SetParamVal<ParamType::TGLboolean>(valueIn, valueOut);
                break;
            case ParamType::TGLbooleanConstPointer:
                SetParamVal<ParamType::TGLbooleanConstPointer>(valueIn, valueOut);
                break;
            case ParamType::TGLbooleanPointer:
                SetParamVal<ParamType::TGLbooleanPointer>(valueIn, valueOut);
                break;
            case ParamType::TGLbyte:
                SetParamVal<ParamType::TGLbyte>(valueIn, valueOut);
                break;
            case ParamType::TGLbyteConstPointer:
                SetParamVal<ParamType::TGLbyteConstPointer>(valueIn, valueOut);
                break;
            case ParamType::TGLcharConstPointer:
                SetParamVal<ParamType::TGLcharConstPointer>(valueIn, valueOut);
                break;
            case ParamType::TGLcharConstPointerPointer:
                SetParamVal<ParamType::TGLcharConstPointerPointer>(valueIn, valueOut);
                break;
            case ParamType::TGLcharPointer:
                SetParamVal<ParamType::TGLcharPointer>(valueIn, valueOut);
                break;
            case ParamType::TGLclampx:
                SetParamVal<ParamType::TGLclampx>(valueIn, valueOut);
                break;
            case ParamType::TGLdouble:
                SetParamVal<ParamType::TGLdouble>(valueIn, valueOut);
                break;
            case ParamType::TGLdoubleConstPointer:
                SetParamVal<ParamType::TGLdoubleConstPointer>(valueIn, valueOut);
                break;
            case ParamType::TGLdoublePointer:
                SetParamVal<ParamType::TGLdoublePointer>(valueIn, valueOut);
                break;
            case ParamType::TGLeglClientBufferEXT:
                SetParamVal<ParamType::TGLeglClientBufferEXT>(valueIn, valueOut);
                break;
            case ParamType::TGLenum:
                SetParamVal<ParamType::TGLenum>(valueIn, valueOut);
                break;
            case ParamType::TGLenumConstPointer:
                SetParamVal<ParamType::TGLenumConstPointer>(valueIn, valueOut);
                break;
            case ParamType::TGLenumPointer:
                SetParamVal<ParamType::TGLenumPointer>(valueIn, valueOut);
                break;
            case ParamType::TGLfixed:
                SetParamVal<ParamType::TGLfixed>(valueIn, valueOut);
                break;
            case ParamType::TGLfixedConstPointer:
                SetParamVal<ParamType::TGLfixedConstPointer>(valueIn, valueOut);
                break;
            case ParamType::TGLfixedPointer:
                SetParamVal<ParamType::TGLfixedPointer>(valueIn, valueOut);
                break;
            case ParamType::TGLfloat:
                SetParamVal<ParamType::TGLfloat>(valueIn, valueOut);
                break;
            case ParamType::TGLfloatConstPointer:
                SetParamVal<ParamType::TGLfloatConstPointer>(valueIn, valueOut);
                break;
            case ParamType::TGLfloatPointer:
                SetParamVal<ParamType::TGLfloatPointer>(valueIn, valueOut);
                break;
            case ParamType::TGLint:
                SetParamVal<ParamType::TGLint>(valueIn, valueOut);
                break;
            case ParamType::TGLint64:
                SetParamVal<ParamType::TGLint64>(valueIn, valueOut);
                break;
            case ParamType::TGLint64Pointer:
                SetParamVal<ParamType::TGLint64Pointer>(valueIn, valueOut);
                break;
            case ParamType::TGLintConstPointer:
                SetParamVal<ParamType::TGLintConstPointer>(valueIn, valueOut);
                break;
            case ParamType::TGLintPointer:
                SetParamVal<ParamType::TGLintPointer>(valueIn, valueOut);
                break;
            case ParamType::TGLintptr:
                SetParamVal<ParamType::TGLintptr>(valueIn, valueOut);
                break;
            case ParamType::TGLintptrConstPointer:
                SetParamVal<ParamType::TGLintptrConstPointer>(valueIn, valueOut);
                break;
            case ParamType::TGLshort:
                SetParamVal<ParamType::TGLshort>(valueIn, valueOut);
                break;
            case ParamType::TGLshortConstPointer:
                SetParamVal<ParamType::TGLshortConstPointer>(valueIn, valueOut);
                break;
            case ParamType::TGLsizei:
                SetParamVal<ParamType::TGLsizei>(valueIn, valueOut);
                break;
            case ParamType::TGLsizeiConstPointer:
                SetParamVal<ParamType::TGLsizeiConstPointer>(valueIn, valueOut);
                break;
            case ParamType::TGLsizeiPointer:
                SetParamVal<ParamType::TGLsizeiPointer>(valueIn, valueOut);
                break;
            case ParamType::TGLsizeiptr:
                SetParamVal<ParamType::TGLsizeiptr>(valueIn, valueOut);
                break;
            case ParamType::TGLsizeiptrConstPointer:
                SetParamVal<ParamType::TGLsizeiptrConstPointer>(valueIn, valueOut);
                break;
            case ParamType::TGLsync:
                SetParamVal<ParamType::TGLsync>(valueIn, valueOut);
                break;
            case ParamType::TGLubyte:
                SetParamVal<ParamType::TGLubyte>(valueIn, valueOut);
                break;
            case ParamType::TGLubyteConstPointer:
                SetParamVal<ParamType::TGLubyteConstPointer>(valueIn, valueOut);
                break;
            case ParamType::TGLubytePointer:
                SetParamVal<ParamType::TGLubytePointer>(valueIn, valueOut);
                break;
            case ParamType::TGLuint:
                SetParamVal<ParamType::TGLuint>(valueIn, valueOut);
                break;
            case ParamType::TGLuint64:
                SetParamVal<ParamType::TGLuint64>(valueIn, valueOut);
                break;
            case ParamType::TGLuint64ConstPointer:
                SetParamVal<ParamType::TGLuint64ConstPointer>(valueIn, valueOut);
                break;
            case ParamType::TGLuint64Pointer:
                SetParamVal<ParamType::TGLuint64Pointer>(valueIn, valueOut);
                break;
            case ParamType::TGLuintConstPointer:
                SetParamVal<ParamType::TGLuintConstPointer>(valueIn, valueOut);
                break;
            case ParamType::TGLuintPointer:
                SetParamVal<ParamType::TGLuintPointer>(valueIn, valueOut);
                break;
            case ParamType::TGLushort:
                SetParamVal<ParamType::TGLushort>(valueIn, valueOut);
                break;
            case ParamType::TGLushortConstPointer:
                SetParamVal<ParamType::TGLushortConstPointer>(valueIn, valueOut);
                break;
            case ParamType::TGLushortPointer:
                SetParamVal<ParamType::TGLushortPointer>(valueIn, valueOut);
                break;
            case ParamType::TGraphicsResetStatus:
                SetParamVal<ParamType::TGraphicsResetStatus>(valueIn, valueOut);
                break;
            case ParamType::THandleType:
                SetParamVal<ParamType::THandleType>(valueIn, valueOut);
                break;
            case ParamType::TImageID:
                SetParamVal<ParamType::TImageID>(valueIn, valueOut);
                break;
            case ParamType::TLightParameter:
                SetParamVal<ParamType::TLightParameter>(valueIn, valueOut);
                break;
            case ParamType::TLogicalOperation:
                SetParamVal<ParamType::TLogicalOperation>(valueIn, valueOut);
                break;
            case ParamType::TMaterialParameter:
                SetParamVal<ParamType::TMaterialParameter>(valueIn, valueOut);
                break;
            case ParamType::TMatrixType:
                SetParamVal<ParamType::TMatrixType>(valueIn, valueOut);
                break;
            case ParamType::TMemoryObjectID:
                SetParamVal<ParamType::TMemoryObjectID>(valueIn, valueOut);
                break;
            case ParamType::TMemoryObjectIDConstPointer:
                SetParamVal<ParamType::TMemoryObjectIDConstPointer>(valueIn, valueOut);
                break;
            case ParamType::TMemoryObjectIDPointer:
                SetParamVal<ParamType::TMemoryObjectIDPointer>(valueIn, valueOut);
                break;
            case ParamType::TObjectType:
                SetParamVal<ParamType::TObjectType>(valueIn, valueOut);
                break;
            case ParamType::TPointParameter:
                SetParamVal<ParamType::TPointParameter>(valueIn, valueOut);
                break;
            case ParamType::TPolygonMode:
                SetParamVal<ParamType::TPolygonMode>(valueIn, valueOut);
                break;
            case ParamType::TPrimitiveMode:
                SetParamVal<ParamType::TPrimitiveMode>(valueIn, valueOut);
                break;
            case ParamType::TProgramPipelineID:
                SetParamVal<ParamType::TProgramPipelineID>(valueIn, valueOut);
                break;
            case ParamType::TProgramPipelineIDConstPointer:
                SetParamVal<ParamType::TProgramPipelineIDConstPointer>(valueIn, valueOut);
                break;
            case ParamType::TProgramPipelineIDPointer:
                SetParamVal<ParamType::TProgramPipelineIDPointer>(valueIn, valueOut);
                break;
            case ParamType::TProvokingVertexConvention:
                SetParamVal<ParamType::TProvokingVertexConvention>(valueIn, valueOut);
                break;
            case ParamType::TQueryID:
                SetParamVal<ParamType::TQueryID>(valueIn, valueOut);
                break;
            case ParamType::TQueryIDConstPointer:
                SetParamVal<ParamType::TQueryIDConstPointer>(valueIn, valueOut);
                break;
            case ParamType::TQueryIDPointer:
                SetParamVal<ParamType::TQueryIDPointer>(valueIn, valueOut);
                break;
            case ParamType::TQueryType:
                SetParamVal<ParamType::TQueryType>(valueIn, valueOut);
                break;
            case ParamType::TRenderbufferID:
                SetParamVal<ParamType::TRenderbufferID>(valueIn, valueOut);
                break;
            case ParamType::TRenderbufferIDConstPointer:
                SetParamVal<ParamType::TRenderbufferIDConstPointer>(valueIn, valueOut);
                break;
            case ParamType::TRenderbufferIDPointer:
                SetParamVal<ParamType::TRenderbufferIDPointer>(valueIn, valueOut);
                break;
            case ParamType::TSamplerID:
                SetParamVal<ParamType::TSamplerID>(valueIn, valueOut);
                break;
            case ParamType::TSamplerIDConstPointer:
                SetParamVal<ParamType::TSamplerIDConstPointer>(valueIn, valueOut);
                break;
            case ParamType::TSamplerIDPointer:
                SetParamVal<ParamType::TSamplerIDPointer>(valueIn, valueOut);
                break;
            case ParamType::TSemaphoreID:
                SetParamVal<ParamType::TSemaphoreID>(valueIn, valueOut);
                break;
            case ParamType::TSemaphoreIDConstPointer:
                SetParamVal<ParamType::TSemaphoreIDConstPointer>(valueIn, valueOut);
                break;
            case ParamType::TSemaphoreIDPointer:
                SetParamVal<ParamType::TSemaphoreIDPointer>(valueIn, valueOut);
                break;
            case ParamType::TShaderProgramID:
                SetParamVal<ParamType::TShaderProgramID>(valueIn, valueOut);
                break;
            case ParamType::TShaderProgramIDConstPointer:
                SetParamVal<ParamType::TShaderProgramIDConstPointer>(valueIn, valueOut);
                break;
            case ParamType::TShaderProgramIDPointer:
                SetParamVal<ParamType::TShaderProgramIDPointer>(valueIn, valueOut);
                break;
            case ParamType::TShaderType:
                SetParamVal<ParamType::TShaderType>(valueIn, valueOut);
                break;
            case ParamType::TShadingModel:
                SetParamVal<ParamType::TShadingModel>(valueIn, valueOut);
                break;
            case ParamType::TSurfaceID:
                SetParamVal<ParamType::TSurfaceID>(valueIn, valueOut);
                break;
            case ParamType::TSyncID:
                SetParamVal<ParamType::TSyncID>(valueIn, valueOut);
                break;
            case ParamType::TTextureEnvParameter:
                SetParamVal<ParamType::TTextureEnvParameter>(valueIn, valueOut);
                break;
            case ParamType::TTextureEnvTarget:
                SetParamVal<ParamType::TTextureEnvTarget>(valueIn, valueOut);
                break;
            case ParamType::TTextureID:
                SetParamVal<ParamType::TTextureID>(valueIn, valueOut);
                break;
            case ParamType::TTextureIDConstPointer:
                SetParamVal<ParamType::TTextureIDConstPointer>(valueIn, valueOut);
                break;
            case ParamType::TTextureIDPointer:
                SetParamVal<ParamType::TTextureIDPointer>(valueIn, valueOut);
                break;
            case ParamType::TTextureTarget:
                SetParamVal<ParamType::TTextureTarget>(valueIn, valueOut);
                break;
            case ParamType::TTextureType:
                SetParamVal<ParamType::TTextureType>(valueIn, valueOut);
                break;
            case ParamType::TTimestamp:
                SetParamVal<ParamType::TTimestamp>(valueIn, valueOut);
                break;
            case ParamType::TTransformFeedbackID:
                SetParamVal<ParamType::TTransformFeedbackID>(valueIn, valueOut);
                break;
            case ParamType::TTransformFeedbackIDConstPointer:
                SetParamVal<ParamType::TTransformFeedbackIDConstPointer>(valueIn, valueOut);
                break;
            case ParamType::TTransformFeedbackIDPointer:
                SetParamVal<ParamType::TTransformFeedbackIDPointer>(valueIn, valueOut);
                break;
            case ParamType::TUniformBlockIndex:
                SetParamVal<ParamType::TUniformBlockIndex>(valueIn, valueOut);
                break;
            case ParamType::TUniformLocation:
                SetParamVal<ParamType::TUniformLocation>(valueIn, valueOut);
                break;
            case ParamType::TVertexArrayID:
                SetParamVal<ParamType::TVertexArrayID>(valueIn, valueOut);
                break;
            case ParamType::TVertexArrayIDConstPointer:
                SetParamVal<ParamType::TVertexArrayIDConstPointer>(valueIn, valueOut);
                break;
            case ParamType::TVertexArrayIDPointer:
                SetParamVal<ParamType::TVertexArrayIDPointer>(valueIn, valueOut);
                break;
            case ParamType::TVertexAttribType:
                SetParamVal<ParamType::TVertexAttribType>(valueIn, valueOut);
                break;
            case ParamType::TcharConstPointer:
                SetParamVal<ParamType::TcharConstPointer>(valueIn, valueOut);
                break;
            case ParamType::Tegl_ConfigPointer:
                SetParamVal<ParamType::Tegl_ConfigPointer>(valueIn, valueOut);
                break;
            case ParamType::Tegl_DevicePointer:
                SetParamVal<ParamType::Tegl_DevicePointer>(valueIn, valueOut);
                break;
            case ParamType::Tegl_DisplayPointer:
                SetParamVal<ParamType::Tegl_DisplayPointer>(valueIn, valueOut);
                break;
            case ParamType::Tegl_StreamPointer:
                SetParamVal<ParamType::Tegl_StreamPointer>(valueIn, valueOut);
                break;
            case ParamType::Tegl_SyncID:
                SetParamVal<ParamType::Tegl_SyncID>(valueIn, valueOut);
                break;
            case ParamType::TvoidConstPointer:
                SetParamVal<ParamType::TvoidConstPointer>(valueIn, valueOut);
                break;
            case ParamType::TvoidConstPointerPointer:
                SetParamVal<ParamType::TvoidConstPointerPointer>(valueIn, valueOut);
                break;
            case ParamType::TvoidPointer:
                SetParamVal<ParamType::TvoidPointer>(valueIn, valueOut);
                break;
            case ParamType::TvoidPointerPointer:
                SetParamVal<ParamType::TvoidPointerPointer>(valueIn, valueOut);
                break;
        }
    }
    
    struct CallCapture;
    struct ParamCapture;
    
    void WriteParamCaptureReplay(std::ostream &os, const CallCapture &call, const ParamCapture &param);
    const char *ParamTypeToString(ParamType paramType);
    
    enum class ResourceIDType
    {
        Buffer,
        Context,
        FenceNV,
        Framebuffer,
        Image,
        MemoryObject,
        ProgramPipeline,
        Query,
        Renderbuffer,
        Sampler,
        Semaphore,
        ShaderProgram,
        Surface,
        Sync,
        Texture,
        TransformFeedback,
        VertexArray,
        egl_Sync,
        EnumCount,
        InvalidEnum = EnumCount
    };
    
    ResourceIDType GetResourceIDTypeFromParamType(ParamType paramType);
    const char *GetResourceIDTypeName(ResourceIDType resourceIDType);
    
    template <typename ResourceType>
    struct GetResourceIDTypeFromType;
    
    template <>
    struct GetResourceIDTypeFromType<gl::BufferID>
    {
        static constexpr ResourceIDType IDType = ResourceIDType::Buffer;
    };
    
    template <>
    struct GetResourceIDTypeFromType<gl::ContextID>
    {
        static constexpr ResourceIDType IDType = ResourceIDType::Context;
    };
    
    template <>
    struct GetResourceIDTypeFromType<gl::FenceNVID>
    {
        static constexpr ResourceIDType IDType = ResourceIDType::FenceNV;
    };
    
    template <>
    struct GetResourceIDTypeFromType<gl::FramebufferID>
    {
        static constexpr ResourceIDType IDType = ResourceIDType::Framebuffer;
    };
    
    template <>
    struct GetResourceIDTypeFromType<egl::ImageID>
    {
        static constexpr ResourceIDType IDType = ResourceIDType::Image;
    };
    
    template <>
    struct GetResourceIDTypeFromType<gl::MemoryObjectID>
    {
        static constexpr ResourceIDType IDType = ResourceIDType::MemoryObject;
    };
    
    template <>
    struct GetResourceIDTypeFromType<gl::ProgramPipelineID>
    {
        static constexpr ResourceIDType IDType = ResourceIDType::ProgramPipeline;
    };
    
    template <>
    struct GetResourceIDTypeFromType<gl::QueryID>
    {
        static constexpr ResourceIDType IDType = ResourceIDType::Query;
    };
    
    template <>
    struct GetResourceIDTypeFromType<gl::RenderbufferID>
    {
        static constexpr ResourceIDType IDType = ResourceIDType::Renderbuffer;
    };
    
    template <>
    struct GetResourceIDTypeFromType<gl::SamplerID>
    {
        static constexpr ResourceIDType IDType = ResourceIDType::Sampler;
    };
    
    template <>
    struct GetResourceIDTypeFromType<gl::SemaphoreID>
    {
        static constexpr ResourceIDType IDType = ResourceIDType::Semaphore;
    };
    
    template <>
    struct GetResourceIDTypeFromType<gl::ShaderProgramID>
    {
        static constexpr ResourceIDType IDType = ResourceIDType::ShaderProgram;
    };
    
    template <>
    struct GetResourceIDTypeFromType<egl::SurfaceID>
    {
        static constexpr ResourceIDType IDType = ResourceIDType::Surface;
    };
    
    template <>
    struct GetResourceIDTypeFromType<gl::SyncID>
    {
        static constexpr ResourceIDType IDType = ResourceIDType::Sync;
    };
    
    template <>
    struct GetResourceIDTypeFromType<gl::TextureID>
    {
        static constexpr ResourceIDType IDType = ResourceIDType::Texture;
    };
    
    template <>
    struct GetResourceIDTypeFromType<gl::TransformFeedbackID>
    {
        static constexpr ResourceIDType IDType = ResourceIDType::TransformFeedback;
    };
    
    template <>
    struct GetResourceIDTypeFromType<gl::VertexArrayID>
    {
        static constexpr ResourceIDType IDType = ResourceIDType::VertexArray;
    };
    
    template <>
    struct GetResourceIDTypeFromType<egl::SyncID>
    {
        static constexpr ResourceIDType IDType = ResourceIDType::egl_Sync;
    };
    
    }  // namespace angle
    
    #endif  // COMMON_FRAME_CAPTURE_UTILS_AUTOGEN_H_