// 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 LIBANGLE_FRAME_CAPTURE_UTILS_AUTOGEN_H_
#define LIBANGLE_FRAME_CAPTURE_UTILS_AUTOGEN_H_

#include "common/PackedEnums.h"

namespace angle
{
enum class ParamType
{
    TAlphaTestFunc,
    TBufferBinding,
    TBufferID,
    TBufferIDConstPointer,
    TBufferIDPointer,
    TBufferUsage,
    TClientVertexArrayType,
    TCullFaceMode,
    TDrawElementsType,
    TFenceNVID,
    TFenceNVIDConstPointer,
    TFenceNVIDPointer,
    TFramebufferID,
    TFramebufferIDConstPointer,
    TFramebufferIDPointer,
    TGLDEBUGPROC,
    TGLDEBUGPROCKHR,
    TGLbitfield,
    TGLboolean,
    TGLbooleanConstPointer,
    TGLbooleanPointer,
    TGLbyte,
    TGLbyteConstPointer,
    TGLcharConstPointer,
    TGLcharConstPointerPointer,
    TGLcharPointer,
    TGLclampx,
    TGLdouble,
    TGLdoubleConstPointer,
    TGLdoublePointer,
    TGLeglImageOES,
    TGLenum,
    TGLenumConstPointer,
    TGLenumPointer,
    TGLfixed,
    TGLfixedConstPointer,
    TGLfixedPointer,
    TGLfloat,
    TGLfloatConstPointer,
    TGLfloatPointer,
    TGLint,
    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,
    TGLvoidConstPointer,
    TGLvoidConstPointerPointer,
    TGraphicsResetStatus,
    THandleType,
    TLightParameter,
    TLogicalOperation,
    TMaterialParameter,
    TMatrixType,
    TMemoryObjectID,
    TMemoryObjectIDConstPointer,
    TMemoryObjectIDPointer,
    TPathID,
    TPointParameter,
    TPrimitiveMode,
    TProgramPipelineID,
    TProgramPipelineIDConstPointer,
    TProgramPipelineIDPointer,
    TProvokingVertexConvention,
    TQueryID,
    TQueryIDConstPointer,
    TQueryIDPointer,
    TQueryType,
    TRenderbufferID,
    TRenderbufferIDConstPointer,
    TRenderbufferIDPointer,
    TSamplerID,
    TSamplerIDConstPointer,
    TSamplerIDPointer,
    TSemaphoreID,
    TSemaphoreIDConstPointer,
    TSemaphoreIDPointer,
    TShaderProgramID,
    TShaderProgramIDConstPointer,
    TShaderProgramIDPointer,
    TShaderType,
    TShadingModel,
    TTextureEnvParameter,
    TTextureEnvTarget,
    TTextureID,
    TTextureIDConstPointer,
    TTextureIDPointer,
    TTextureTarget,
    TTextureType,
    TTransformFeedbackID,
    TTransformFeedbackIDConstPointer,
    TTransformFeedbackIDPointer,
    TVertexArrayID,
    TVertexArrayIDConstPointer,
    TVertexArrayIDPointer,
    TVertexAttribType,
    TvoidConstPointer,
    TvoidConstPointerPointer,
    TvoidPointer,
    TvoidPointerPointer,
};

constexpr uint32_t kParamTypeCount = 120;

union ParamValue
{
    gl::AlphaTestFunc AlphaTestFuncVal;
    gl::BufferBinding BufferBindingVal;
    gl::BufferID BufferIDVal;
    const gl::BufferID *BufferIDConstPointerVal;
    gl::BufferID *BufferIDPointerVal;
    gl::BufferUsage BufferUsageVal;
    gl::ClientVertexArrayType ClientVertexArrayTypeVal;
    gl::CullFaceMode CullFaceModeVal;
    gl::DrawElementsType DrawElementsTypeVal;
    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;
    GLeglImageOES GLeglImageOESVal;
    GLenum GLenumVal;
    const GLenum *GLenumConstPointerVal;
    GLenum *GLenumPointerVal;
    GLfixed GLfixedVal;
    const GLfixed *GLfixedConstPointerVal;
    GLfixed *GLfixedPointerVal;
    GLfloat GLfloatVal;
    const GLfloat *GLfloatConstPointerVal;
    GLfloat *GLfloatPointerVal;
    GLint GLintVal;
    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;
    const GLvoid *GLvoidConstPointerVal;
    const GLvoid *const *GLvoidConstPointerPointerVal;
    gl::GraphicsResetStatus GraphicsResetStatusVal;
    gl::HandleType HandleTypeVal;
    gl::LightParameter LightParameterVal;
    gl::LogicalOperation LogicalOperationVal;
    gl::MaterialParameter MaterialParameterVal;
    gl::MatrixType MatrixTypeVal;
    gl::MemoryObjectID MemoryObjectIDVal;
    const gl::MemoryObjectID *MemoryObjectIDConstPointerVal;
    gl::MemoryObjectID *MemoryObjectIDPointerVal;
    gl::PathID PathIDVal;
    gl::PointParameter PointParameterVal;
    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;
    gl::TextureEnvParameter TextureEnvParameterVal;
    gl::TextureEnvTarget TextureEnvTargetVal;
    gl::TextureID TextureIDVal;
    const gl::TextureID *TextureIDConstPointerVal;
    gl::TextureID *TextureIDPointerVal;
    gl::TextureTarget TextureTargetVal;
    gl::TextureType TextureTypeVal;
    gl::TransformFeedbackID TransformFeedbackIDVal;
    const gl::TransformFeedbackID *TransformFeedbackIDConstPointerVal;
    gl::TransformFeedbackID *TransformFeedbackIDPointerVal;
    gl::VertexArrayID VertexArrayIDVal;
    const gl::VertexArrayID *VertexArrayIDConstPointerVal;
    gl::VertexArrayID *VertexArrayIDPointerVal;
    gl::VertexAttribType VertexAttribTypeVal;
    const void *voidConstPointerVal;
    const void *const *voidConstPointerPointerVal;
    void *voidPointerVal;
    void **voidPointerPointerVal;
};

template <ParamType PType, typename T>
T GetParamVal(const ParamValue &value);

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::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 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 GLeglImageOES GetParamVal<ParamType::TGLeglImageOES, GLeglImageOES>(const ParamValue &value)
{
    return value.GLeglImageOESVal;
}

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::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 const GLvoid *GetParamVal<ParamType::TGLvoidConstPointer, const GLvoid *>(
    const ParamValue &value)
{
    return value.GLvoidConstPointerVal;
}

template <>
inline const GLvoid *const *
GetParamVal<ParamType::TGLvoidConstPointerPointer, const GLvoid *const *>(const ParamValue &value)
{
    return value.GLvoidConstPointerPointerVal;
}

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 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 gl::PathID GetParamVal<ParamType::TPathID, gl::PathID>(const ParamValue &value)
{
    return value.PathIDVal;
}

template <>
inline gl::PointParameter GetParamVal<ParamType::TPointParameter, gl::PointParameter>(
    const ParamValue &value)
{
    return value.PointParameterVal;
}

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 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 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::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 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::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::TCullFaceMode:
            return GetParamVal<ParamType::TCullFaceMode, T>(value);
        case ParamType::TDrawElementsType:
            return GetParamVal<ParamType::TDrawElementsType, 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::TGLeglImageOES:
            return GetParamVal<ParamType::TGLeglImageOES, 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::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::TGLvoidConstPointer:
            return GetParamVal<ParamType::TGLvoidConstPointer, T>(value);
        case ParamType::TGLvoidConstPointerPointer:
            return GetParamVal<ParamType::TGLvoidConstPointerPointer, T>(value);
        case ParamType::TGraphicsResetStatus:
            return GetParamVal<ParamType::TGraphicsResetStatus, T>(value);
        case ParamType::THandleType:
            return GetParamVal<ParamType::THandleType, 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::TPathID:
            return GetParamVal<ParamType::TPathID, T>(value);
        case ParamType::TPointParameter:
            return GetParamVal<ParamType::TPointParameter, 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::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::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::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::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);
    }
}

template <ParamType PType, typename T>
void SetParamVal(T valueIn, ParamValue *valueOut);

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::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::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::TGLeglImageOES>(GLeglImageOES valueIn, ParamValue *valueOut)
{
    valueOut->GLeglImageOESVal = 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::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::TGLvoidConstPointer>(const GLvoid *valueIn, ParamValue *valueOut)
{
    valueOut->GLvoidConstPointerVal = valueIn;
}

template <>
inline void SetParamVal<ParamType::TGLvoidConstPointerPointer>(const GLvoid *const *valueIn,
                                                               ParamValue *valueOut)
{
    valueOut->GLvoidConstPointerPointerVal = 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::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::TPathID>(gl::PathID valueIn, ParamValue *valueOut)
{
    valueOut->PathIDVal = valueIn;
}

template <>
inline void SetParamVal<ParamType::TPointParameter>(gl::PointParameter valueIn,
                                                    ParamValue *valueOut)
{
    valueOut->PointParameterVal = 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::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::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::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::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::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::TCullFaceMode:
            SetParamVal<ParamType::TCullFaceMode>(valueIn, valueOut);
            break;
        case ParamType::TDrawElementsType:
            SetParamVal<ParamType::TDrawElementsType>(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::TGLeglImageOES:
            SetParamVal<ParamType::TGLeglImageOES>(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::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::TGLvoidConstPointer:
            SetParamVal<ParamType::TGLvoidConstPointer>(valueIn, valueOut);
            break;
        case ParamType::TGLvoidConstPointerPointer:
            SetParamVal<ParamType::TGLvoidConstPointerPointer>(valueIn, valueOut);
            break;
        case ParamType::TGraphicsResetStatus:
            SetParamVal<ParamType::TGraphicsResetStatus>(valueIn, valueOut);
            break;
        case ParamType::THandleType:
            SetParamVal<ParamType::THandleType>(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::TPathID:
            SetParamVal<ParamType::TPathID>(valueIn, valueOut);
            break;
        case ParamType::TPointParameter:
            SetParamVal<ParamType::TPointParameter>(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::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::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::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::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;
    }
}

void WriteParamTypeToStream(std::ostream &os, ParamType paramType, const ParamValue &paramValue);
const char *ParamTypeToString(ParamType paramType);

enum class ResourceIDType
{
    Buffer,
    FenceNV,
    Framebuffer,
    MemoryObject,
    Path,
    ProgramPipeline,
    Query,
    Renderbuffer,
    Sampler,
    Semaphore,
    ShaderProgram,
    Texture,
    TransformFeedback,
    VertexArray,
    EnumCount,
    InvalidEnum = EnumCount
};

ResourceIDType GetResourceIDTypeFromParamType(ParamType paramType);
const char *GetResourceIDTypeName(ResourceIDType resourceIDType);
}  // namespace angle

#endif  // LIBANGLE_FRAME_CAPTURE_UTILS_AUTOGEN_H_
