chromium/third_party/angle/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
{ … };

constexpr uint32_t kParamTypeCount = …;

ParamValue;

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

template <>
inline const AHardwareBuffer *GetParamVal<ParamType::TAHardwareBufferConstPointer,
                                          const AHardwareBuffer *>(const ParamValue &value)
{ … }

template <>
inline gl::AlphaTestFunc GetParamVal<ParamType::TAlphaTestFunc, gl::AlphaTestFunc>(
    const ParamValue &value)
{ … }

template <>
inline gl::BufferBinding GetParamVal<ParamType::TBufferBinding, gl::BufferBinding>(
    const ParamValue &value)
{ … }

template <>
inline gl::BufferID GetParamVal<ParamType::TBufferID, gl::BufferID>(const ParamValue &value)
{ … }

template <>
inline const gl::BufferID *GetParamVal<ParamType::TBufferIDConstPointer, const gl::BufferID *>(
    const ParamValue &value)
{ … }

template <>
inline gl::BufferID *GetParamVal<ParamType::TBufferIDPointer, gl::BufferID *>(
    const ParamValue &value)
{ … }

template <>
inline gl::BufferUsage GetParamVal<ParamType::TBufferUsage, gl::BufferUsage>(
    const ParamValue &value)
{ … }

template <>
inline gl::ClientVertexArrayType
GetParamVal<ParamType::TClientVertexArrayType, gl::ClientVertexArrayType>(const ParamValue &value)
{ … }

template <>
inline gl::ClipDepthMode GetParamVal<ParamType::TClipDepthMode, gl::ClipDepthMode>(
    const ParamValue &value)
{ … }

template <>
inline gl::ClipOrigin GetParamVal<ParamType::TClipOrigin, gl::ClipOrigin>(const ParamValue &value)
{ … }

template <>
inline egl::CompositorTiming GetParamVal<ParamType::TCompositorTiming, egl::CompositorTiming>(
    const ParamValue &value)
{ … }

template <>
inline gl::ContextID GetParamVal<ParamType::TContextID, gl::ContextID>(const ParamValue &value)
{ … }

template <>
inline gl::CullFaceMode GetParamVal<ParamType::TCullFaceMode, gl::CullFaceMode>(
    const ParamValue &value)
{ … }

template <>
inline gl::DrawElementsType GetParamVal<ParamType::TDrawElementsType, gl::DrawElementsType>(
    const ParamValue &value)
{ … }

template <>
inline const EGLAttrib *GetParamVal<ParamType::TEGLAttribConstPointer, const EGLAttrib *>(
    const ParamValue &value)
{ … }

template <>
inline EGLAttribKHR *GetParamVal<ParamType::TEGLAttribKHRPointer, EGLAttribKHR *>(
    const ParamValue &value)
{ … }

template <>
inline EGLAttrib *GetParamVal<ParamType::TEGLAttribPointer, EGLAttrib *>(const ParamValue &value)
{ … }

template <>
inline EGLBoolean GetParamVal<ParamType::TEGLBoolean, EGLBoolean>(const ParamValue &value)
{ … }

template <>
inline EGLBoolean *GetParamVal<ParamType::TEGLBooleanPointer, EGLBoolean *>(const ParamValue &value)
{ … }

template <>
inline EGLClientBuffer GetParamVal<ParamType::TEGLClientBuffer, EGLClientBuffer>(
    const ParamValue &value)
{ … }

template <>
inline EGLConfig *GetParamVal<ParamType::TEGLConfigPointer, EGLConfig *>(const ParamValue &value)
{ … }

template <>
inline EGLContext GetParamVal<ParamType::TEGLContext, EGLContext>(const ParamValue &value)
{ … }

template <>
inline EGLDEBUGPROCKHR GetParamVal<ParamType::TEGLDEBUGPROCKHR, EGLDEBUGPROCKHR>(
    const ParamValue &value)
{ … }

template <>
inline EGLDeviceEXT GetParamVal<ParamType::TEGLDeviceEXT, EGLDeviceEXT>(const ParamValue &value)
{ … }

template <>
inline EGLDisplay GetParamVal<ParamType::TEGLDisplay, EGLDisplay>(const ParamValue &value)
{ … }

template <>
inline EGLFrameTokenANGLE GetParamVal<ParamType::TEGLFrameTokenANGLE, EGLFrameTokenANGLE>(
    const ParamValue &value)
{ … }

template <>
inline EGLGetBlobFuncANDROID GetParamVal<ParamType::TEGLGetBlobFuncANDROID, EGLGetBlobFuncANDROID>(
    const ParamValue &value)
{ … }

template <>
inline EGLImage GetParamVal<ParamType::TEGLImage, EGLImage>(const ParamValue &value)
{ … }

template <>
inline EGLImageKHR GetParamVal<ParamType::TEGLImageKHR, EGLImageKHR>(const ParamValue &value)
{ … }

template <>
inline EGLLabelKHR GetParamVal<ParamType::TEGLLabelKHR, EGLLabelKHR>(const ParamValue &value)
{ … }

template <>
inline EGLNativeDisplayType GetParamVal<ParamType::TEGLNativeDisplayType, EGLNativeDisplayType>(
    const ParamValue &value)
{ … }

template <>
inline EGLNativePixmapType GetParamVal<ParamType::TEGLNativePixmapType, EGLNativePixmapType>(
    const ParamValue &value)
{ … }

template <>
inline EGLNativeWindowType GetParamVal<ParamType::TEGLNativeWindowType, EGLNativeWindowType>(
    const ParamValue &value)
{ … }

template <>
inline EGLObjectKHR GetParamVal<ParamType::TEGLObjectKHR, EGLObjectKHR>(const ParamValue &value)
{ … }

template <>
inline EGLSetBlobFuncANDROID GetParamVal<ParamType::TEGLSetBlobFuncANDROID, EGLSetBlobFuncANDROID>(
    const ParamValue &value)
{ … }

template <>
inline EGLStreamKHR GetParamVal<ParamType::TEGLStreamKHR, EGLStreamKHR>(const ParamValue &value)
{ … }

template <>
inline EGLSurface GetParamVal<ParamType::TEGLSurface, EGLSurface>(const ParamValue &value)
{ … }

template <>
inline EGLSync GetParamVal<ParamType::TEGLSync, EGLSync>(const ParamValue &value)
{ … }

template <>
inline EGLSyncKHR GetParamVal<ParamType::TEGLSyncKHR, EGLSyncKHR>(const ParamValue &value)
{ … }

template <>
inline EGLTime GetParamVal<ParamType::TEGLTime, EGLTime>(const ParamValue &value)
{ … }

template <>
inline EGLTimeKHR GetParamVal<ParamType::TEGLTimeKHR, EGLTimeKHR>(const ParamValue &value)
{ … }

template <>
inline EGLenum GetParamVal<ParamType::TEGLenum, EGLenum>(const ParamValue &value)
{ … }

template <>
inline EGLint GetParamVal<ParamType::TEGLint, EGLint>(const ParamValue &value)
{ … }

template <>
inline const EGLint *GetParamVal<ParamType::TEGLintConstPointer, const EGLint *>(
    const ParamValue &value)
{ … }

template <>
inline EGLint *GetParamVal<ParamType::TEGLintPointer, EGLint *>(const ParamValue &value)
{ … }

template <>
inline EGLnsecsANDROID GetParamVal<ParamType::TEGLnsecsANDROID, EGLnsecsANDROID>(
    const ParamValue &value)
{ … }

template <>
inline EGLnsecsANDROID *GetParamVal<ParamType::TEGLnsecsANDROIDPointer, EGLnsecsANDROID *>(
    const ParamValue &value)
{ … }

template <>
inline EGLuint64KHR GetParamVal<ParamType::TEGLuint64KHR, EGLuint64KHR>(const ParamValue &value)
{ … }

template <>
inline EGLuint64KHR *GetParamVal<ParamType::TEGLuint64KHRPointer, EGLuint64KHR *>(
    const ParamValue &value)
{ … }

template <>
inline gl::FenceNVID GetParamVal<ParamType::TFenceNVID, gl::FenceNVID>(const ParamValue &value)
{ … }

template <>
inline const gl::FenceNVID *GetParamVal<ParamType::TFenceNVIDConstPointer, const gl::FenceNVID *>(
    const ParamValue &value)
{ … }

template <>
inline gl::FenceNVID *GetParamVal<ParamType::TFenceNVIDPointer, gl::FenceNVID *>(
    const ParamValue &value)
{ … }

template <>
inline gl::FramebufferID GetParamVal<ParamType::TFramebufferID, gl::FramebufferID>(
    const ParamValue &value)
{ … }

template <>
inline const gl::FramebufferID *GetParamVal<ParamType::TFramebufferIDConstPointer,
                                            const gl::FramebufferID *>(const ParamValue &value)
{ … }

template <>
inline gl::FramebufferID *GetParamVal<ParamType::TFramebufferIDPointer, gl::FramebufferID *>(
    const ParamValue &value)
{ … }

template <>
inline GLDEBUGPROC GetParamVal<ParamType::TGLDEBUGPROC, GLDEBUGPROC>(const ParamValue &value)
{ … }

template <>
inline GLDEBUGPROCKHR GetParamVal<ParamType::TGLDEBUGPROCKHR, GLDEBUGPROCKHR>(
    const ParamValue &value)
{ … }

template <>
inline GLbitfield GetParamVal<ParamType::TGLbitfield, GLbitfield>(const ParamValue &value)
{ … }

template <>
inline GLboolean GetParamVal<ParamType::TGLboolean, GLboolean>(const ParamValue &value)
{ … }

template <>
inline const GLboolean *GetParamVal<ParamType::TGLbooleanConstPointer, const GLboolean *>(
    const ParamValue &value)
{ … }

template <>
inline GLboolean *GetParamVal<ParamType::TGLbooleanPointer, GLboolean *>(const ParamValue &value)
{ … }

template <>
inline GLbyte GetParamVal<ParamType::TGLbyte, GLbyte>(const ParamValue &value)
{ … }

template <>
inline const GLbyte *GetParamVal<ParamType::TGLbyteConstPointer, const GLbyte *>(
    const ParamValue &value)
{ … }

template <>
inline const GLchar *GetParamVal<ParamType::TGLcharConstPointer, const GLchar *>(
    const ParamValue &value)
{ … }

template <>
inline const GLchar *const *
GetParamVal<ParamType::TGLcharConstPointerPointer, const GLchar *const *>(const ParamValue &value)
{ … }

template <>
inline GLchar *GetParamVal<ParamType::TGLcharPointer, GLchar *>(const ParamValue &value)
{ … }

template <>
inline GLclampx GetParamVal<ParamType::TGLclampx, GLclampx>(const ParamValue &value)
{ … }

template <>
inline GLdouble GetParamVal<ParamType::TGLdouble, GLdouble>(const ParamValue &value)
{ … }

template <>
inline const GLdouble *GetParamVal<ParamType::TGLdoubleConstPointer, const GLdouble *>(
    const ParamValue &value)
{ … }

template <>
inline GLdouble *GetParamVal<ParamType::TGLdoublePointer, GLdouble *>(const ParamValue &value)
{ … }

template <>
inline GLeglClientBufferEXT GetParamVal<ParamType::TGLeglClientBufferEXT, GLeglClientBufferEXT>(
    const ParamValue &value)
{ … }

template <>
inline GLenum GetParamVal<ParamType::TGLenum, GLenum>(const ParamValue &value)
{ … }

template <>
inline const GLenum *GetParamVal<ParamType::TGLenumConstPointer, const GLenum *>(
    const ParamValue &value)
{ … }

template <>
inline GLenum *GetParamVal<ParamType::TGLenumPointer, GLenum *>(const ParamValue &value)
{ … }

template <>
inline GLfixed GetParamVal<ParamType::TGLfixed, GLfixed>(const ParamValue &value)
{ … }

template <>
inline const GLfixed *GetParamVal<ParamType::TGLfixedConstPointer, const GLfixed *>(
    const ParamValue &value)
{ … }

template <>
inline GLfixed *GetParamVal<ParamType::TGLfixedPointer, GLfixed *>(const ParamValue &value)
{ … }

template <>
inline GLfloat GetParamVal<ParamType::TGLfloat, GLfloat>(const ParamValue &value)
{ … }

template <>
inline const GLfloat *GetParamVal<ParamType::TGLfloatConstPointer, const GLfloat *>(
    const ParamValue &value)
{ … }

template <>
inline GLfloat *GetParamVal<ParamType::TGLfloatPointer, GLfloat *>(const ParamValue &value)
{ … }

template <>
inline GLint GetParamVal<ParamType::TGLint, GLint>(const ParamValue &value)
{ … }

template <>
inline GLint64 GetParamVal<ParamType::TGLint64, GLint64>(const ParamValue &value)
{ … }

template <>
inline GLint64 *GetParamVal<ParamType::TGLint64Pointer, GLint64 *>(const ParamValue &value)
{ … }

template <>
inline const GLint *GetParamVal<ParamType::TGLintConstPointer, const GLint *>(
    const ParamValue &value)
{ … }

template <>
inline GLint *GetParamVal<ParamType::TGLintPointer, GLint *>(const ParamValue &value)
{ … }

template <>
inline GLintptr GetParamVal<ParamType::TGLintptr, GLintptr>(const ParamValue &value)
{ … }

template <>
inline const GLintptr *GetParamVal<ParamType::TGLintptrConstPointer, const GLintptr *>(
    const ParamValue &value)
{ … }

template <>
inline GLshort GetParamVal<ParamType::TGLshort, GLshort>(const ParamValue &value)
{ … }

template <>
inline const GLshort *GetParamVal<ParamType::TGLshortConstPointer, const GLshort *>(
    const ParamValue &value)
{ … }

template <>
inline GLsizei GetParamVal<ParamType::TGLsizei, GLsizei>(const ParamValue &value)
{ … }

template <>
inline const GLsizei *GetParamVal<ParamType::TGLsizeiConstPointer, const GLsizei *>(
    const ParamValue &value)
{ … }

template <>
inline GLsizei *GetParamVal<ParamType::TGLsizeiPointer, GLsizei *>(const ParamValue &value)
{ … }

template <>
inline GLsizeiptr GetParamVal<ParamType::TGLsizeiptr, GLsizeiptr>(const ParamValue &value)
{ … }

template <>
inline const GLsizeiptr *GetParamVal<ParamType::TGLsizeiptrConstPointer, const GLsizeiptr *>(
    const ParamValue &value)
{ … }

template <>
inline GLsync GetParamVal<ParamType::TGLsync, GLsync>(const ParamValue &value)
{ … }

template <>
inline GLubyte GetParamVal<ParamType::TGLubyte, GLubyte>(const ParamValue &value)
{ … }

template <>
inline const GLubyte *GetParamVal<ParamType::TGLubyteConstPointer, const GLubyte *>(
    const ParamValue &value)
{ … }

template <>
inline GLubyte *GetParamVal<ParamType::TGLubytePointer, GLubyte *>(const ParamValue &value)
{ … }

template <>
inline GLuint GetParamVal<ParamType::TGLuint, GLuint>(const ParamValue &value)
{ … }

template <>
inline GLuint64 GetParamVal<ParamType::TGLuint64, GLuint64>(const ParamValue &value)
{ … }

template <>
inline const GLuint64 *GetParamVal<ParamType::TGLuint64ConstPointer, const GLuint64 *>(
    const ParamValue &value)
{ … }

template <>
inline GLuint64 *GetParamVal<ParamType::TGLuint64Pointer, GLuint64 *>(const ParamValue &value)
{ … }

template <>
inline const GLuint *GetParamVal<ParamType::TGLuintConstPointer, const GLuint *>(
    const ParamValue &value)
{ … }

template <>
inline GLuint *GetParamVal<ParamType::TGLuintPointer, GLuint *>(const ParamValue &value)
{ … }

template <>
inline GLushort GetParamVal<ParamType::TGLushort, GLushort>(const ParamValue &value)
{ … }

template <>
inline const GLushort *GetParamVal<ParamType::TGLushortConstPointer, const GLushort *>(
    const ParamValue &value)
{ … }

template <>
inline GLushort *GetParamVal<ParamType::TGLushortPointer, GLushort *>(const ParamValue &value)
{ … }

template <>
inline gl::GraphicsResetStatus
GetParamVal<ParamType::TGraphicsResetStatus, gl::GraphicsResetStatus>(const ParamValue &value)
{ … }

template <>
inline gl::HandleType GetParamVal<ParamType::THandleType, gl::HandleType>(const ParamValue &value)
{ … }

template <>
inline egl::ImageID GetParamVal<ParamType::TImageID, egl::ImageID>(const ParamValue &value)
{ … }

template <>
inline gl::LightParameter GetParamVal<ParamType::TLightParameter, gl::LightParameter>(
    const ParamValue &value)
{ … }

template <>
inline gl::LogicalOperation GetParamVal<ParamType::TLogicalOperation, gl::LogicalOperation>(
    const ParamValue &value)
{ … }

template <>
inline gl::MaterialParameter GetParamVal<ParamType::TMaterialParameter, gl::MaterialParameter>(
    const ParamValue &value)
{ … }

template <>
inline gl::MatrixType GetParamVal<ParamType::TMatrixType, gl::MatrixType>(const ParamValue &value)
{ … }

template <>
inline gl::MemoryObjectID GetParamVal<ParamType::TMemoryObjectID, gl::MemoryObjectID>(
    const ParamValue &value)
{ … }

template <>
inline const gl::MemoryObjectID *GetParamVal<ParamType::TMemoryObjectIDConstPointer,
                                             const gl::MemoryObjectID *>(const ParamValue &value)
{ … }

template <>
inline gl::MemoryObjectID *GetParamVal<ParamType::TMemoryObjectIDPointer, gl::MemoryObjectID *>(
    const ParamValue &value)
{ … }

template <>
inline egl::ObjectType GetParamVal<ParamType::TObjectType, egl::ObjectType>(const ParamValue &value)
{ … }

template <>
inline gl::PointParameter GetParamVal<ParamType::TPointParameter, gl::PointParameter>(
    const ParamValue &value)
{ … }

template <>
inline gl::PolygonMode GetParamVal<ParamType::TPolygonMode, gl::PolygonMode>(
    const ParamValue &value)
{ … }

template <>
inline gl::PrimitiveMode GetParamVal<ParamType::TPrimitiveMode, gl::PrimitiveMode>(
    const ParamValue &value)
{ … }

template <>
inline gl::ProgramPipelineID GetParamVal<ParamType::TProgramPipelineID, gl::ProgramPipelineID>(
    const ParamValue &value)
{ … }

template <>
inline const gl::ProgramPipelineID *
GetParamVal<ParamType::TProgramPipelineIDConstPointer, const gl::ProgramPipelineID *>(
    const ParamValue &value)
{ … }

template <>
inline gl::ProgramPipelineID *
GetParamVal<ParamType::TProgramPipelineIDPointer, gl::ProgramPipelineID *>(const ParamValue &value)
{ … }

template <>
inline gl::ProvokingVertexConvention
GetParamVal<ParamType::TProvokingVertexConvention, gl::ProvokingVertexConvention>(
    const ParamValue &value)
{ … }

template <>
inline gl::QueryID GetParamVal<ParamType::TQueryID, gl::QueryID>(const ParamValue &value)
{ … }

template <>
inline const gl::QueryID *GetParamVal<ParamType::TQueryIDConstPointer, const gl::QueryID *>(
    const ParamValue &value)
{ … }

template <>
inline gl::QueryID *GetParamVal<ParamType::TQueryIDPointer, gl::QueryID *>(const ParamValue &value)
{ … }

template <>
inline gl::QueryType GetParamVal<ParamType::TQueryType, gl::QueryType>(const ParamValue &value)
{ … }

template <>
inline gl::RenderbufferID GetParamVal<ParamType::TRenderbufferID, gl::RenderbufferID>(
    const ParamValue &value)
{ … }

template <>
inline const gl::RenderbufferID *GetParamVal<ParamType::TRenderbufferIDConstPointer,
                                             const gl::RenderbufferID *>(const ParamValue &value)
{ … }

template <>
inline gl::RenderbufferID *GetParamVal<ParamType::TRenderbufferIDPointer, gl::RenderbufferID *>(
    const ParamValue &value)
{ … }

template <>
inline gl::SamplerID GetParamVal<ParamType::TSamplerID, gl::SamplerID>(const ParamValue &value)
{ … }

template <>
inline const gl::SamplerID *GetParamVal<ParamType::TSamplerIDConstPointer, const gl::SamplerID *>(
    const ParamValue &value)
{ … }

template <>
inline gl::SamplerID *GetParamVal<ParamType::TSamplerIDPointer, gl::SamplerID *>(
    const ParamValue &value)
{ … }

template <>
inline gl::SemaphoreID GetParamVal<ParamType::TSemaphoreID, gl::SemaphoreID>(
    const ParamValue &value)
{ … }

template <>
inline const gl::SemaphoreID *
GetParamVal<ParamType::TSemaphoreIDConstPointer, const gl::SemaphoreID *>(const ParamValue &value)
{ … }

template <>
inline gl::SemaphoreID *GetParamVal<ParamType::TSemaphoreIDPointer, gl::SemaphoreID *>(
    const ParamValue &value)
{ … }

template <>
inline gl::ShaderProgramID GetParamVal<ParamType::TShaderProgramID, gl::ShaderProgramID>(
    const ParamValue &value)
{ … }

template <>
inline const gl::ShaderProgramID *GetParamVal<ParamType::TShaderProgramIDConstPointer,
                                              const gl::ShaderProgramID *>(const ParamValue &value)
{ … }

template <>
inline gl::ShaderProgramID *GetParamVal<ParamType::TShaderProgramIDPointer, gl::ShaderProgramID *>(
    const ParamValue &value)
{ … }

template <>
inline gl::ShaderType GetParamVal<ParamType::TShaderType, gl::ShaderType>(const ParamValue &value)
{ … }

template <>
inline gl::ShadingModel GetParamVal<ParamType::TShadingModel, gl::ShadingModel>(
    const ParamValue &value)
{ … }

template <>
inline egl::SurfaceID GetParamVal<ParamType::TSurfaceID, egl::SurfaceID>(const ParamValue &value)
{ … }

template <>
inline gl::SyncID GetParamVal<ParamType::TSyncID, gl::SyncID>(const ParamValue &value)
{ … }

template <>
inline gl::TextureEnvParameter
GetParamVal<ParamType::TTextureEnvParameter, gl::TextureEnvParameter>(const ParamValue &value)
{ … }

template <>
inline gl::TextureEnvTarget GetParamVal<ParamType::TTextureEnvTarget, gl::TextureEnvTarget>(
    const ParamValue &value)
{ … }

template <>
inline gl::TextureID GetParamVal<ParamType::TTextureID, gl::TextureID>(const ParamValue &value)
{ … }

template <>
inline const gl::TextureID *GetParamVal<ParamType::TTextureIDConstPointer, const gl::TextureID *>(
    const ParamValue &value)
{ … }

template <>
inline gl::TextureID *GetParamVal<ParamType::TTextureIDPointer, gl::TextureID *>(
    const ParamValue &value)
{ … }

template <>
inline gl::TextureTarget GetParamVal<ParamType::TTextureTarget, gl::TextureTarget>(
    const ParamValue &value)
{ … }

template <>
inline gl::TextureType GetParamVal<ParamType::TTextureType, gl::TextureType>(
    const ParamValue &value)
{ … }

template <>
inline egl::Timestamp GetParamVal<ParamType::TTimestamp, egl::Timestamp>(const ParamValue &value)
{ … }

template <>
inline gl::TransformFeedbackID
GetParamVal<ParamType::TTransformFeedbackID, gl::TransformFeedbackID>(const ParamValue &value)
{ … }

template <>
inline const gl::TransformFeedbackID *
GetParamVal<ParamType::TTransformFeedbackIDConstPointer, const gl::TransformFeedbackID *>(
    const ParamValue &value)
{ … }

template <>
inline gl::TransformFeedbackID *GetParamVal<ParamType::TTransformFeedbackIDPointer,
                                            gl::TransformFeedbackID *>(const ParamValue &value)
{ … }

template <>
inline gl::UniformBlockIndex GetParamVal<ParamType::TUniformBlockIndex, gl::UniformBlockIndex>(
    const ParamValue &value)
{ … }

template <>
inline gl::UniformLocation GetParamVal<ParamType::TUniformLocation, gl::UniformLocation>(
    const ParamValue &value)
{ … }

template <>
inline gl::VertexArrayID GetParamVal<ParamType::TVertexArrayID, gl::VertexArrayID>(
    const ParamValue &value)
{ … }

template <>
inline const gl::VertexArrayID *GetParamVal<ParamType::TVertexArrayIDConstPointer,
                                            const gl::VertexArrayID *>(const ParamValue &value)
{ … }

template <>
inline gl::VertexArrayID *GetParamVal<ParamType::TVertexArrayIDPointer, gl::VertexArrayID *>(
    const ParamValue &value)
{ … }

template <>
inline gl::VertexAttribType GetParamVal<ParamType::TVertexAttribType, gl::VertexAttribType>(
    const ParamValue &value)
{ … }

template <>
inline const char *GetParamVal<ParamType::TcharConstPointer, const char *>(const ParamValue &value)
{ … }

template <>
inline egl::Config *GetParamVal<ParamType::Tegl_ConfigPointer, egl::Config *>(
    const ParamValue &value)
{ … }

template <>
inline egl::Device *GetParamVal<ParamType::Tegl_DevicePointer, egl::Device *>(
    const ParamValue &value)
{ … }

template <>
inline egl::Display *GetParamVal<ParamType::Tegl_DisplayPointer, egl::Display *>(
    const ParamValue &value)
{ … }

template <>
inline egl::Stream *GetParamVal<ParamType::Tegl_StreamPointer, egl::Stream *>(
    const ParamValue &value)
{ … }

template <>
inline egl::SyncID GetParamVal<ParamType::Tegl_SyncID, egl::SyncID>(const ParamValue &value)
{ … }

template <>
inline const void *GetParamVal<ParamType::TvoidConstPointer, const void *>(const ParamValue &value)
{ … }

template <>
inline const void *const *GetParamVal<ParamType::TvoidConstPointerPointer, const void *const *>(
    const ParamValue &value)
{ … }

template <>
inline void *GetParamVal<ParamType::TvoidPointer, void *>(const ParamValue &value)
{ … }

template <>
inline void **GetParamVal<ParamType::TvoidPointerPointer, void **>(const ParamValue &value)
{ … }

template <ParamType PType, typename T>
T GetParamVal(const ParamValue &value)
{ … }

template <typename T>
T AccessParamValue(ParamType paramType, const ParamValue &value)
{ … }

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

template <>
inline void SetParamVal<ParamType::TAHardwareBufferConstPointer>(const AHardwareBuffer *valueIn,
                                                                 ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TAlphaTestFunc>(gl::AlphaTestFunc valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TBufferBinding>(gl::BufferBinding valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TBufferID>(gl::BufferID valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TBufferIDConstPointer>(const gl::BufferID *valueIn,
                                                          ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TBufferIDPointer>(gl::BufferID *valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TBufferUsage>(gl::BufferUsage valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TClientVertexArrayType>(gl::ClientVertexArrayType valueIn,
                                                           ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TClipDepthMode>(gl::ClipDepthMode valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TClipOrigin>(gl::ClipOrigin valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TCompositorTiming>(egl::CompositorTiming valueIn,
                                                      ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TContextID>(gl::ContextID valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TCullFaceMode>(gl::CullFaceMode valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TDrawElementsType>(gl::DrawElementsType valueIn,
                                                      ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TEGLAttribConstPointer>(const EGLAttrib *valueIn,
                                                           ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TEGLAttribKHRPointer>(EGLAttribKHR *valueIn,
                                                         ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TEGLAttribPointer>(EGLAttrib *valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TEGLBoolean>(EGLBoolean valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TEGLBooleanPointer>(EGLBoolean *valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TEGLClientBuffer>(EGLClientBuffer valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TEGLConfigPointer>(EGLConfig *valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TEGLContext>(EGLContext valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TEGLDEBUGPROCKHR>(EGLDEBUGPROCKHR valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TEGLDeviceEXT>(EGLDeviceEXT valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TEGLDisplay>(EGLDisplay valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TEGLFrameTokenANGLE>(EGLFrameTokenANGLE valueIn,
                                                        ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TEGLGetBlobFuncANDROID>(EGLGetBlobFuncANDROID valueIn,
                                                           ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TEGLImage>(EGLImage valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TEGLImageKHR>(EGLImageKHR valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TEGLLabelKHR>(EGLLabelKHR valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TEGLNativeDisplayType>(EGLNativeDisplayType valueIn,
                                                          ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TEGLNativePixmapType>(EGLNativePixmapType valueIn,
                                                         ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TEGLNativeWindowType>(EGLNativeWindowType valueIn,
                                                         ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TEGLObjectKHR>(EGLObjectKHR valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TEGLSetBlobFuncANDROID>(EGLSetBlobFuncANDROID valueIn,
                                                           ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TEGLStreamKHR>(EGLStreamKHR valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TEGLSurface>(EGLSurface valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TEGLSync>(EGLSync valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TEGLSyncKHR>(EGLSyncKHR valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TEGLTime>(EGLTime valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TEGLTimeKHR>(EGLTimeKHR valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TEGLenum>(EGLenum valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TEGLint>(EGLint valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TEGLintConstPointer>(const EGLint *valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TEGLintPointer>(EGLint *valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TEGLnsecsANDROID>(EGLnsecsANDROID valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TEGLnsecsANDROIDPointer>(EGLnsecsANDROID *valueIn,
                                                            ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TEGLuint64KHR>(EGLuint64KHR valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TEGLuint64KHRPointer>(EGLuint64KHR *valueIn,
                                                         ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TFenceNVID>(gl::FenceNVID valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TFenceNVIDConstPointer>(const gl::FenceNVID *valueIn,
                                                           ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TFenceNVIDPointer>(gl::FenceNVID *valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TFramebufferID>(gl::FramebufferID valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TFramebufferIDConstPointer>(const gl::FramebufferID *valueIn,
                                                               ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TFramebufferIDPointer>(gl::FramebufferID *valueIn,
                                                          ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLDEBUGPROC>(GLDEBUGPROC valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLDEBUGPROCKHR>(GLDEBUGPROCKHR valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLbitfield>(GLbitfield valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLboolean>(GLboolean valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLbooleanConstPointer>(const GLboolean *valueIn,
                                                           ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLbooleanPointer>(GLboolean *valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLbyte>(GLbyte valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLbyteConstPointer>(const GLbyte *valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLcharConstPointer>(const GLchar *valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLcharConstPointerPointer>(const GLchar *const *valueIn,
                                                               ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLcharPointer>(GLchar *valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLclampx>(GLclampx valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLdouble>(GLdouble valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLdoubleConstPointer>(const GLdouble *valueIn,
                                                          ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLdoublePointer>(GLdouble *valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLeglClientBufferEXT>(GLeglClientBufferEXT valueIn,
                                                          ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLenum>(GLenum valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLenumConstPointer>(const GLenum *valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLenumPointer>(GLenum *valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLfixed>(GLfixed valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLfixedConstPointer>(const GLfixed *valueIn,
                                                         ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLfixedPointer>(GLfixed *valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLfloat>(GLfloat valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLfloatConstPointer>(const GLfloat *valueIn,
                                                         ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLfloatPointer>(GLfloat *valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLint>(GLint valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLint64>(GLint64 valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLint64Pointer>(GLint64 *valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLintConstPointer>(const GLint *valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLintPointer>(GLint *valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLintptr>(GLintptr valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLintptrConstPointer>(const GLintptr *valueIn,
                                                          ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLshort>(GLshort valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLshortConstPointer>(const GLshort *valueIn,
                                                         ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLsizei>(GLsizei valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLsizeiConstPointer>(const GLsizei *valueIn,
                                                         ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLsizeiPointer>(GLsizei *valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLsizeiptr>(GLsizeiptr valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLsizeiptrConstPointer>(const GLsizeiptr *valueIn,
                                                            ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLsync>(GLsync valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLubyte>(GLubyte valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLubyteConstPointer>(const GLubyte *valueIn,
                                                         ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLubytePointer>(GLubyte *valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLuint>(GLuint valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLuint64>(GLuint64 valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLuint64ConstPointer>(const GLuint64 *valueIn,
                                                          ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLuint64Pointer>(GLuint64 *valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLuintConstPointer>(const GLuint *valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLuintPointer>(GLuint *valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLushort>(GLushort valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLushortConstPointer>(const GLushort *valueIn,
                                                          ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGLushortPointer>(GLushort *valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TGraphicsResetStatus>(gl::GraphicsResetStatus valueIn,
                                                         ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::THandleType>(gl::HandleType valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TImageID>(egl::ImageID valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TLightParameter>(gl::LightParameter valueIn,
                                                    ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TLogicalOperation>(gl::LogicalOperation valueIn,
                                                      ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TMaterialParameter>(gl::MaterialParameter valueIn,
                                                       ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TMatrixType>(gl::MatrixType valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TMemoryObjectID>(gl::MemoryObjectID valueIn,
                                                    ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TMemoryObjectIDConstPointer>(const gl::MemoryObjectID *valueIn,
                                                                ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TMemoryObjectIDPointer>(gl::MemoryObjectID *valueIn,
                                                           ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TObjectType>(egl::ObjectType valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TPointParameter>(gl::PointParameter valueIn,
                                                    ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TPolygonMode>(gl::PolygonMode valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TPrimitiveMode>(gl::PrimitiveMode valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TProgramPipelineID>(gl::ProgramPipelineID valueIn,
                                                       ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TProgramPipelineIDConstPointer>(
    const gl::ProgramPipelineID *valueIn,
    ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TProgramPipelineIDPointer>(gl::ProgramPipelineID *valueIn,
                                                              ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TProvokingVertexConvention>(
    gl::ProvokingVertexConvention valueIn,
    ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TQueryID>(gl::QueryID valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TQueryIDConstPointer>(const gl::QueryID *valueIn,
                                                         ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TQueryIDPointer>(gl::QueryID *valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TQueryType>(gl::QueryType valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TRenderbufferID>(gl::RenderbufferID valueIn,
                                                    ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TRenderbufferIDConstPointer>(const gl::RenderbufferID *valueIn,
                                                                ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TRenderbufferIDPointer>(gl::RenderbufferID *valueIn,
                                                           ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TSamplerID>(gl::SamplerID valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TSamplerIDConstPointer>(const gl::SamplerID *valueIn,
                                                           ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TSamplerIDPointer>(gl::SamplerID *valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TSemaphoreID>(gl::SemaphoreID valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TSemaphoreIDConstPointer>(const gl::SemaphoreID *valueIn,
                                                             ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TSemaphoreIDPointer>(gl::SemaphoreID *valueIn,
                                                        ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TShaderProgramID>(gl::ShaderProgramID valueIn,
                                                     ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TShaderProgramIDConstPointer>(const gl::ShaderProgramID *valueIn,
                                                                 ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TShaderProgramIDPointer>(gl::ShaderProgramID *valueIn,
                                                            ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TShaderType>(gl::ShaderType valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TShadingModel>(gl::ShadingModel valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TSurfaceID>(egl::SurfaceID valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TSyncID>(gl::SyncID valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TTextureEnvParameter>(gl::TextureEnvParameter valueIn,
                                                         ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TTextureEnvTarget>(gl::TextureEnvTarget valueIn,
                                                      ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TTextureID>(gl::TextureID valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TTextureIDConstPointer>(const gl::TextureID *valueIn,
                                                           ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TTextureIDPointer>(gl::TextureID *valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TTextureTarget>(gl::TextureTarget valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TTextureType>(gl::TextureType valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TTimestamp>(egl::Timestamp valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TTransformFeedbackID>(gl::TransformFeedbackID valueIn,
                                                         ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TTransformFeedbackIDConstPointer>(
    const gl::TransformFeedbackID *valueIn,
    ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TTransformFeedbackIDPointer>(gl::TransformFeedbackID *valueIn,
                                                                ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TUniformBlockIndex>(gl::UniformBlockIndex valueIn,
                                                       ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TUniformLocation>(gl::UniformLocation valueIn,
                                                     ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TVertexArrayID>(gl::VertexArrayID valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TVertexArrayIDConstPointer>(const gl::VertexArrayID *valueIn,
                                                               ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TVertexArrayIDPointer>(gl::VertexArrayID *valueIn,
                                                          ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TVertexAttribType>(gl::VertexAttribType valueIn,
                                                      ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TcharConstPointer>(const char *valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::Tegl_ConfigPointer>(egl::Config *valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::Tegl_DevicePointer>(egl::Device *valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::Tegl_DisplayPointer>(egl::Display *valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::Tegl_StreamPointer>(egl::Stream *valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::Tegl_SyncID>(egl::SyncID valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TvoidConstPointer>(const void *valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TvoidConstPointerPointer>(const void *const *valueIn,
                                                             ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TvoidPointer>(void *valueIn, ParamValue *valueOut)
{ … }

template <>
inline void SetParamVal<ParamType::TvoidPointerPointer>(void **valueIn, ParamValue *valueOut)
{ … }

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

template <typename T>
void InitParamValue(ParamType paramType, T valueIn, ParamValue *valueOut)
{ … }

struct CallCapture;
struct ParamCapture;

void WriteParamCaptureReplay(std::ostream &os, const CallCapture &call, const ParamCapture &param);
const char *ParamTypeToString(ParamType paramType);

enum class ResourceIDType
{ … };

ResourceIDType GetResourceIDTypeFromParamType(ParamType paramType);
const char *GetResourceIDTypeName(ResourceIDType resourceIDType);

template <typename ResourceType>
struct GetResourceIDTypeFromType;

template <>
struct GetResourceIDTypeFromType<gl::BufferID>
{ … };

template <>
struct GetResourceIDTypeFromType<gl::ContextID>
{ … };

template <>
struct GetResourceIDTypeFromType<gl::FenceNVID>
{ … };

template <>
struct GetResourceIDTypeFromType<gl::FramebufferID>
{ … };

template <>
struct GetResourceIDTypeFromType<egl::ImageID>
{ … };

template <>
struct GetResourceIDTypeFromType<gl::MemoryObjectID>
{ … };

template <>
struct GetResourceIDTypeFromType<gl::ProgramPipelineID>
{ … };

template <>
struct GetResourceIDTypeFromType<gl::QueryID>
{ … };

template <>
struct GetResourceIDTypeFromType<gl::RenderbufferID>
{ … };

template <>
struct GetResourceIDTypeFromType<gl::SamplerID>
{ … };

template <>
struct GetResourceIDTypeFromType<gl::SemaphoreID>
{ … };

template <>
struct GetResourceIDTypeFromType<gl::ShaderProgramID>
{ … };

template <>
struct GetResourceIDTypeFromType<egl::SurfaceID>
{ … };

template <>
struct GetResourceIDTypeFromType<gl::SyncID>
{ … };

template <>
struct GetResourceIDTypeFromType<gl::TextureID>
{ … };

template <>
struct GetResourceIDTypeFromType<gl::TransformFeedbackID>
{ … };

template <>
struct GetResourceIDTypeFromType<gl::VertexArrayID>
{ … };

template <>
struct GetResourceIDTypeFromType<egl::SyncID>
{ … };

}  // namespace angle

#endif  // COMMON_FRAME_CAPTURE_UTILS_AUTOGEN_H_