// 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.cpp:
//   ANGLE Frame capture types and helper functions.

#include "common/frame_capture_utils_autogen.h"

#include "common/frame_capture_utils.h"

namespace angle
{
void WriteParamCaptureReplay(std::ostream &os, const CallCapture &call, const ParamCapture &param)
{
    switch (param.type)
    {
        case ParamType::TAHardwareBufferConstPointer:
            WriteParamValueReplay<ParamType::TAHardwareBufferConstPointer>(
                os, call, param.value.AHardwareBufferConstPointerVal);
            break;
        case ParamType::TAlphaTestFunc:
            WriteParamValueReplay<ParamType::TAlphaTestFunc>(os, call,
                                                             param.value.AlphaTestFuncVal);
            break;
        case ParamType::TBufferBinding:
            WriteParamValueReplay<ParamType::TBufferBinding>(os, call,
                                                             param.value.BufferBindingVal);
            break;
        case ParamType::TBufferID:
            WriteParamValueReplay<ParamType::TBufferID>(os, call, param.value.BufferIDVal);
            break;
        case ParamType::TBufferIDConstPointer:
            WriteParamValueReplay<ParamType::TBufferIDConstPointer>(
                os, call, param.value.BufferIDConstPointerVal);
            break;
        case ParamType::TBufferIDPointer:
            WriteParamValueReplay<ParamType::TBufferIDPointer>(os, call,
                                                               param.value.BufferIDPointerVal);
            break;
        case ParamType::TBufferParam:
            WriteParamValueReplay<ParamType::TBufferParam>(os, call, param.value.BufferParamVal);
            break;
        case ParamType::TBufferUsage:
            WriteParamValueReplay<ParamType::TBufferUsage>(os, call, param.value.BufferUsageVal);
            break;
        case ParamType::TClientVertexArrayType:
            WriteParamValueReplay<ParamType::TClientVertexArrayType>(
                os, call, param.value.ClientVertexArrayTypeVal);
            break;
        case ParamType::TClipDepthMode:
            WriteParamValueReplay<ParamType::TClipDepthMode>(os, call,
                                                             param.value.ClipDepthModeVal);
            break;
        case ParamType::TClipOrigin:
            WriteParamValueReplay<ParamType::TClipOrigin>(os, call, param.value.ClipOriginVal);
            break;
        case ParamType::TCombinerOp:
            WriteParamValueReplay<ParamType::TCombinerOp>(os, call, param.value.CombinerOpVal);
            break;
        case ParamType::TCompositorTiming:
            WriteParamValueReplay<ParamType::TCompositorTiming>(os, call,
                                                                param.value.CompositorTimingVal);
            break;
        case ParamType::TContextID:
            WriteParamValueReplay<ParamType::TContextID>(os, call, param.value.ContextIDVal);
            break;
        case ParamType::TCullFaceMode:
            WriteParamValueReplay<ParamType::TCullFaceMode>(os, call, param.value.CullFaceModeVal);
            break;
        case ParamType::TDrawElementsType:
            WriteParamValueReplay<ParamType::TDrawElementsType>(os, call,
                                                                param.value.DrawElementsTypeVal);
            break;
        case ParamType::TEGLAttribConstPointer:
            WriteParamValueReplay<ParamType::TEGLAttribConstPointer>(
                os, call, param.value.EGLAttribConstPointerVal);
            break;
        case ParamType::TEGLAttribKHRPointer:
            WriteParamValueReplay<ParamType::TEGLAttribKHRPointer>(
                os, call, param.value.EGLAttribKHRPointerVal);
            break;
        case ParamType::TEGLAttribPointer:
            WriteParamValueReplay<ParamType::TEGLAttribPointer>(os, call,
                                                                param.value.EGLAttribPointerVal);
            break;
        case ParamType::TEGLBoolean:
            WriteParamValueReplay<ParamType::TEGLBoolean>(os, call, param.value.EGLBooleanVal);
            break;
        case ParamType::TEGLBooleanPointer:
            WriteParamValueReplay<ParamType::TEGLBooleanPointer>(os, call,
                                                                 param.value.EGLBooleanPointerVal);
            break;
        case ParamType::TEGLClientBuffer:
            WriteParamValueReplay<ParamType::TEGLClientBuffer>(os, call,
                                                               param.value.EGLClientBufferVal);
            break;
        case ParamType::TEGLConfigPointer:
            WriteParamValueReplay<ParamType::TEGLConfigPointer>(os, call,
                                                                param.value.EGLConfigPointerVal);
            break;
        case ParamType::TEGLContext:
            WriteParamValueReplay<ParamType::TEGLContext>(os, call, param.value.EGLContextVal);
            break;
        case ParamType::TEGLDEBUGPROCKHR:
            WriteParamValueReplay<ParamType::TEGLDEBUGPROCKHR>(os, call,
                                                               param.value.EGLDEBUGPROCKHRVal);
            break;
        case ParamType::TEGLDeviceEXT:
            WriteParamValueReplay<ParamType::TEGLDeviceEXT>(os, call, param.value.EGLDeviceEXTVal);
            break;
        case ParamType::TEGLDisplay:
            WriteParamValueReplay<ParamType::TEGLDisplay>(os, call, param.value.EGLDisplayVal);
            break;
        case ParamType::TEGLGetBlobFuncANDROID:
            WriteParamValueReplay<ParamType::TEGLGetBlobFuncANDROID>(
                os, call, param.value.EGLGetBlobFuncANDROIDVal);
            break;
        case ParamType::TEGLImage:
            WriteParamValueReplay<ParamType::TEGLImage>(os, call, param.value.EGLImageVal);
            break;
        case ParamType::TEGLImageKHR:
            WriteParamValueReplay<ParamType::TEGLImageKHR>(os, call, param.value.EGLImageKHRVal);
            break;
        case ParamType::TEGLLabelKHR:
            WriteParamValueReplay<ParamType::TEGLLabelKHR>(os, call, param.value.EGLLabelKHRVal);
            break;
        case ParamType::TEGLNativeDisplayType:
            WriteParamValueReplay<ParamType::TEGLNativeDisplayType>(
                os, call, param.value.EGLNativeDisplayTypeVal);
            break;
        case ParamType::TEGLNativePixmapType:
            WriteParamValueReplay<ParamType::TEGLNativePixmapType>(
                os, call, param.value.EGLNativePixmapTypeVal);
            break;
        case ParamType::TEGLNativeWindowType:
            WriteParamValueReplay<ParamType::TEGLNativeWindowType>(
                os, call, param.value.EGLNativeWindowTypeVal);
            break;
        case ParamType::TEGLObjectKHR:
            WriteParamValueReplay<ParamType::TEGLObjectKHR>(os, call, param.value.EGLObjectKHRVal);
            break;
        case ParamType::TEGLSetBlobFuncANDROID:
            WriteParamValueReplay<ParamType::TEGLSetBlobFuncANDROID>(
                os, call, param.value.EGLSetBlobFuncANDROIDVal);
            break;
        case ParamType::TEGLStreamKHR:
            WriteParamValueReplay<ParamType::TEGLStreamKHR>(os, call, param.value.EGLStreamKHRVal);
            break;
        case ParamType::TEGLSurface:
            WriteParamValueReplay<ParamType::TEGLSurface>(os, call, param.value.EGLSurfaceVal);
            break;
        case ParamType::TEGLSync:
            WriteParamValueReplay<ParamType::TEGLSync>(os, call, param.value.EGLSyncVal);
            break;
        case ParamType::TEGLSyncKHR:
            WriteParamValueReplay<ParamType::TEGLSyncKHR>(os, call, param.value.EGLSyncKHRVal);
            break;
        case ParamType::TEGLTime:
            WriteParamValueReplay<ParamType::TEGLTime>(os, call, param.value.EGLTimeVal);
            break;
        case ParamType::TEGLTimeKHR:
            WriteParamValueReplay<ParamType::TEGLTimeKHR>(os, call, param.value.EGLTimeKHRVal);
            break;
        case ParamType::TEGLenum:
            WriteParamValueReplay<ParamType::TEGLenum>(os, call, param.value.EGLenumVal);
            break;
        case ParamType::TEGLint:
            WriteParamValueReplay<ParamType::TEGLint>(os, call, param.value.EGLintVal);
            break;
        case ParamType::TEGLintConstPointer:
            WriteParamValueReplay<ParamType::TEGLintConstPointer>(
                os, call, param.value.EGLintConstPointerVal);
            break;
        case ParamType::TEGLintPointer:
            WriteParamValueReplay<ParamType::TEGLintPointer>(os, call,
                                                             param.value.EGLintPointerVal);
            break;
        case ParamType::TEGLnsecsANDROID:
            WriteParamValueReplay<ParamType::TEGLnsecsANDROID>(os, call,
                                                               param.value.EGLnsecsANDROIDVal);
            break;
        case ParamType::TEGLnsecsANDROIDPointer:
            WriteParamValueReplay<ParamType::TEGLnsecsANDROIDPointer>(
                os, call, param.value.EGLnsecsANDROIDPointerVal);
            break;
        case ParamType::TEGLuint64KHR:
            WriteParamValueReplay<ParamType::TEGLuint64KHR>(os, call, param.value.EGLuint64KHRVal);
            break;
        case ParamType::TEGLuint64KHRPointer:
            WriteParamValueReplay<ParamType::TEGLuint64KHRPointer>(
                os, call, param.value.EGLuint64KHRPointerVal);
            break;
        case ParamType::TFenceNVID:
            WriteParamValueReplay<ParamType::TFenceNVID>(os, call, param.value.FenceNVIDVal);
            break;
        case ParamType::TFenceNVIDConstPointer:
            WriteParamValueReplay<ParamType::TFenceNVIDConstPointer>(
                os, call, param.value.FenceNVIDConstPointerVal);
            break;
        case ParamType::TFenceNVIDPointer:
            WriteParamValueReplay<ParamType::TFenceNVIDPointer>(os, call,
                                                                param.value.FenceNVIDPointerVal);
            break;
        case ParamType::TFramebufferID:
            WriteParamValueReplay<ParamType::TFramebufferID>(os, call,
                                                             param.value.FramebufferIDVal);
            break;
        case ParamType::TFramebufferIDConstPointer:
            WriteParamValueReplay<ParamType::TFramebufferIDConstPointer>(
                os, call, param.value.FramebufferIDConstPointerVal);
            break;
        case ParamType::TFramebufferIDPointer:
            WriteParamValueReplay<ParamType::TFramebufferIDPointer>(
                os, call, param.value.FramebufferIDPointerVal);
            break;
        case ParamType::TFramebufferParameter:
            WriteParamValueReplay<ParamType::TFramebufferParameter>(
                os, call, param.value.FramebufferParameterVal);
            break;
        case ParamType::TGLDEBUGPROC:
            WriteParamValueReplay<ParamType::TGLDEBUGPROC>(os, call, param.value.GLDEBUGPROCVal);
            break;
        case ParamType::TGLDEBUGPROCKHR:
            WriteParamValueReplay<ParamType::TGLDEBUGPROCKHR>(os, call,
                                                              param.value.GLDEBUGPROCKHRVal);
            break;
        case ParamType::TGLGETBLOBPROCANGLE:
            WriteParamValueReplay<ParamType::TGLGETBLOBPROCANGLE>(
                os, call, param.value.GLGETBLOBPROCANGLEVal);
            break;
        case ParamType::TGLSETBLOBPROCANGLE:
            WriteParamValueReplay<ParamType::TGLSETBLOBPROCANGLE>(
                os, call, param.value.GLSETBLOBPROCANGLEVal);
            break;
        case ParamType::TGLbitfield:
            WriteParamValueReplay<ParamType::TGLbitfield>(os, call, param.value.GLbitfieldVal);
            break;
        case ParamType::TGLboolean:
            WriteParamValueReplay<ParamType::TGLboolean>(os, call, param.value.GLbooleanVal);
            break;
        case ParamType::TGLbooleanPointer:
            WriteParamValueReplay<ParamType::TGLbooleanPointer>(os, call,
                                                                param.value.GLbooleanPointerVal);
            break;
        case ParamType::TGLcharConstPointer:
            WriteParamValueReplay<ParamType::TGLcharConstPointer>(
                os, call, param.value.GLcharConstPointerVal);
            break;
        case ParamType::TGLcharConstPointerPointer:
            WriteParamValueReplay<ParamType::TGLcharConstPointerPointer>(
                os, call, param.value.GLcharConstPointerPointerVal);
            break;
        case ParamType::TGLcharPointer:
            WriteParamValueReplay<ParamType::TGLcharPointer>(os, call,
                                                             param.value.GLcharPointerVal);
            break;
        case ParamType::TGLclampx:
            WriteParamValueReplay<ParamType::TGLclampx>(os, call, param.value.GLclampxVal);
            break;
        case ParamType::TGLeglClientBufferEXT:
            WriteParamValueReplay<ParamType::TGLeglClientBufferEXT>(
                os, call, param.value.GLeglClientBufferEXTVal);
            break;
        case ParamType::TGLenum:
            WriteParamValueReplay<ParamType::TGLenum>(os, call, param.value.GLenumVal);
            break;
        case ParamType::TGLenumConstPointer:
            WriteParamValueReplay<ParamType::TGLenumConstPointer>(
                os, call, param.value.GLenumConstPointerVal);
            break;
        case ParamType::TGLenumPointer:
            WriteParamValueReplay<ParamType::TGLenumPointer>(os, call,
                                                             param.value.GLenumPointerVal);
            break;
        case ParamType::TGLfixed:
            WriteParamValueReplay<ParamType::TGLfixed>(os, call, param.value.GLfixedVal);
            break;
        case ParamType::TGLfixedConstPointer:
            WriteParamValueReplay<ParamType::TGLfixedConstPointer>(
                os, call, param.value.GLfixedConstPointerVal);
            break;
        case ParamType::TGLfixedPointer:
            WriteParamValueReplay<ParamType::TGLfixedPointer>(os, call,
                                                              param.value.GLfixedPointerVal);
            break;
        case ParamType::TGLfloat:
            WriteParamValueReplay<ParamType::TGLfloat>(os, call, param.value.GLfloatVal);
            break;
        case ParamType::TGLfloatConstPointer:
            WriteParamValueReplay<ParamType::TGLfloatConstPointer>(
                os, call, param.value.GLfloatConstPointerVal);
            break;
        case ParamType::TGLfloatPointer:
            WriteParamValueReplay<ParamType::TGLfloatPointer>(os, call,
                                                              param.value.GLfloatPointerVal);
            break;
        case ParamType::TGLint:
            WriteParamValueReplay<ParamType::TGLint>(os, call, param.value.GLintVal);
            break;
        case ParamType::TGLint64:
            WriteParamValueReplay<ParamType::TGLint64>(os, call, param.value.GLint64Val);
            break;
        case ParamType::TGLint64Pointer:
            WriteParamValueReplay<ParamType::TGLint64Pointer>(os, call,
                                                              param.value.GLint64PointerVal);
            break;
        case ParamType::TGLintConstPointer:
            WriteParamValueReplay<ParamType::TGLintConstPointer>(os, call,
                                                                 param.value.GLintConstPointerVal);
            break;
        case ParamType::TGLintPointer:
            WriteParamValueReplay<ParamType::TGLintPointer>(os, call, param.value.GLintPointerVal);
            break;
        case ParamType::TGLintptr:
            WriteParamValueReplay<ParamType::TGLintptr>(os, call, param.value.GLintptrVal);
            break;
        case ParamType::TGLshort:
            WriteParamValueReplay<ParamType::TGLshort>(os, call, param.value.GLshortVal);
            break;
        case ParamType::TGLshortConstPointer:
            WriteParamValueReplay<ParamType::TGLshortConstPointer>(
                os, call, param.value.GLshortConstPointerVal);
            break;
        case ParamType::TGLsizei:
            WriteParamValueReplay<ParamType::TGLsizei>(os, call, param.value.GLsizeiVal);
            break;
        case ParamType::TGLsizeiConstPointer:
            WriteParamValueReplay<ParamType::TGLsizeiConstPointer>(
                os, call, param.value.GLsizeiConstPointerVal);
            break;
        case ParamType::TGLsizeiPointer:
            WriteParamValueReplay<ParamType::TGLsizeiPointer>(os, call,
                                                              param.value.GLsizeiPointerVal);
            break;
        case ParamType::TGLsizeiptr:
            WriteParamValueReplay<ParamType::TGLsizeiptr>(os, call, param.value.GLsizeiptrVal);
            break;
        case ParamType::TGLsync:
            WriteParamValueReplay<ParamType::TGLsync>(os, call, param.value.GLsyncVal);
            break;
        case ParamType::TGLubyte:
            WriteParamValueReplay<ParamType::TGLubyte>(os, call, param.value.GLubyteVal);
            break;
        case ParamType::TGLubyteConstPointer:
            WriteParamValueReplay<ParamType::TGLubyteConstPointer>(
                os, call, param.value.GLubyteConstPointerVal);
            break;
        case ParamType::TGLubytePointer:
            WriteParamValueReplay<ParamType::TGLubytePointer>(os, call,
                                                              param.value.GLubytePointerVal);
            break;
        case ParamType::TGLuint:
            WriteParamValueReplay<ParamType::TGLuint>(os, call, param.value.GLuintVal);
            break;
        case ParamType::TGLuint64:
            WriteParamValueReplay<ParamType::TGLuint64>(os, call, param.value.GLuint64Val);
            break;
        case ParamType::TGLuint64ConstPointer:
            WriteParamValueReplay<ParamType::TGLuint64ConstPointer>(
                os, call, param.value.GLuint64ConstPointerVal);
            break;
        case ParamType::TGLuint64Pointer:
            WriteParamValueReplay<ParamType::TGLuint64Pointer>(os, call,
                                                               param.value.GLuint64PointerVal);
            break;
        case ParamType::TGLuintConstPointer:
            WriteParamValueReplay<ParamType::TGLuintConstPointer>(
                os, call, param.value.GLuintConstPointerVal);
            break;
        case ParamType::TGLuintPointer:
            WriteParamValueReplay<ParamType::TGLuintPointer>(os, call,
                                                             param.value.GLuintPointerVal);
            break;
        case ParamType::TGraphicsResetStatus:
            WriteParamValueReplay<ParamType::TGraphicsResetStatus>(
                os, call, param.value.GraphicsResetStatusVal);
            break;
        case ParamType::THandleType:
            WriteParamValueReplay<ParamType::THandleType>(os, call, param.value.HandleTypeVal);
            break;
        case ParamType::TImageID:
            WriteParamValueReplay<ParamType::TImageID>(os, call, param.value.ImageIDVal);
            break;
        case ParamType::TLightParameter:
            WriteParamValueReplay<ParamType::TLightParameter>(os, call,
                                                              param.value.LightParameterVal);
            break;
        case ParamType::TLogicalOperation:
            WriteParamValueReplay<ParamType::TLogicalOperation>(os, call,
                                                                param.value.LogicalOperationVal);
            break;
        case ParamType::TMaterialParameter:
            WriteParamValueReplay<ParamType::TMaterialParameter>(os, call,
                                                                 param.value.MaterialParameterVal);
            break;
        case ParamType::TMatrixType:
            WriteParamValueReplay<ParamType::TMatrixType>(os, call, param.value.MatrixTypeVal);
            break;
        case ParamType::TMemoryObjectID:
            WriteParamValueReplay<ParamType::TMemoryObjectID>(os, call,
                                                              param.value.MemoryObjectIDVal);
            break;
        case ParamType::TMemoryObjectIDConstPointer:
            WriteParamValueReplay<ParamType::TMemoryObjectIDConstPointer>(
                os, call, param.value.MemoryObjectIDConstPointerVal);
            break;
        case ParamType::TMemoryObjectIDPointer:
            WriteParamValueReplay<ParamType::TMemoryObjectIDPointer>(
                os, call, param.value.MemoryObjectIDPointerVal);
            break;
        case ParamType::TObjectType:
            WriteParamValueReplay<ParamType::TObjectType>(os, call, param.value.ObjectTypeVal);
            break;
        case ParamType::TPackUnpackParameter:
            WriteParamValueReplay<ParamType::TPackUnpackParameter>(
                os, call, param.value.PackUnpackParameterVal);
            break;
        case ParamType::TPlaneParameter:
            WriteParamValueReplay<ParamType::TPlaneParameter>(os, call,
                                                              param.value.PlaneParameterVal);
            break;
        case ParamType::TPointParameter:
            WriteParamValueReplay<ParamType::TPointParameter>(os, call,
                                                              param.value.PointParameterVal);
            break;
        case ParamType::TPolygonMode:
            WriteParamValueReplay<ParamType::TPolygonMode>(os, call, param.value.PolygonModeVal);
            break;
        case ParamType::TPrimitiveMode:
            WriteParamValueReplay<ParamType::TPrimitiveMode>(os, call,
                                                             param.value.PrimitiveModeVal);
            break;
        case ParamType::TProgramPipelineID:
            WriteParamValueReplay<ParamType::TProgramPipelineID>(os, call,
                                                                 param.value.ProgramPipelineIDVal);
            break;
        case ParamType::TProgramPipelineIDConstPointer:
            WriteParamValueReplay<ParamType::TProgramPipelineIDConstPointer>(
                os, call, param.value.ProgramPipelineIDConstPointerVal);
            break;
        case ParamType::TProgramPipelineIDPointer:
            WriteParamValueReplay<ParamType::TProgramPipelineIDPointer>(
                os, call, param.value.ProgramPipelineIDPointerVal);
            break;
        case ParamType::TProvokingVertexConvention:
            WriteParamValueReplay<ParamType::TProvokingVertexConvention>(
                os, call, param.value.ProvokingVertexConventionVal);
            break;
        case ParamType::TQueryID:
            WriteParamValueReplay<ParamType::TQueryID>(os, call, param.value.QueryIDVal);
            break;
        case ParamType::TQueryIDConstPointer:
            WriteParamValueReplay<ParamType::TQueryIDConstPointer>(
                os, call, param.value.QueryIDConstPointerVal);
            break;
        case ParamType::TQueryIDPointer:
            WriteParamValueReplay<ParamType::TQueryIDPointer>(os, call,
                                                              param.value.QueryIDPointerVal);
            break;
        case ParamType::TQueryObjectParameter:
            WriteParamValueReplay<ParamType::TQueryObjectParameter>(
                os, call, param.value.QueryObjectParameterVal);
            break;
        case ParamType::TQueryParameter:
            WriteParamValueReplay<ParamType::TQueryParameter>(os, call,
                                                              param.value.QueryParameterVal);
            break;
        case ParamType::TQueryType:
            WriteParamValueReplay<ParamType::TQueryType>(os, call, param.value.QueryTypeVal);
            break;
        case ParamType::TRenderbufferID:
            WriteParamValueReplay<ParamType::TRenderbufferID>(os, call,
                                                              param.value.RenderbufferIDVal);
            break;
        case ParamType::TRenderbufferIDConstPointer:
            WriteParamValueReplay<ParamType::TRenderbufferIDConstPointer>(
                os, call, param.value.RenderbufferIDConstPointerVal);
            break;
        case ParamType::TRenderbufferIDPointer:
            WriteParamValueReplay<ParamType::TRenderbufferIDPointer>(
                os, call, param.value.RenderbufferIDPointerVal);
            break;
        case ParamType::TSamplerID:
            WriteParamValueReplay<ParamType::TSamplerID>(os, call, param.value.SamplerIDVal);
            break;
        case ParamType::TSamplerIDConstPointer:
            WriteParamValueReplay<ParamType::TSamplerIDConstPointer>(
                os, call, param.value.SamplerIDConstPointerVal);
            break;
        case ParamType::TSamplerIDPointer:
            WriteParamValueReplay<ParamType::TSamplerIDPointer>(os, call,
                                                                param.value.SamplerIDPointerVal);
            break;
        case ParamType::TSamplerParameter:
            WriteParamValueReplay<ParamType::TSamplerParameter>(os, call,
                                                                param.value.SamplerParameterVal);
            break;
        case ParamType::TSemaphoreID:
            WriteParamValueReplay<ParamType::TSemaphoreID>(os, call, param.value.SemaphoreIDVal);
            break;
        case ParamType::TSemaphoreIDConstPointer:
            WriteParamValueReplay<ParamType::TSemaphoreIDConstPointer>(
                os, call, param.value.SemaphoreIDConstPointerVal);
            break;
        case ParamType::TSemaphoreIDPointer:
            WriteParamValueReplay<ParamType::TSemaphoreIDPointer>(
                os, call, param.value.SemaphoreIDPointerVal);
            break;
        case ParamType::TShaderParameter:
            WriteParamValueReplay<ParamType::TShaderParameter>(os, call,
                                                               param.value.ShaderParameterVal);
            break;
        case ParamType::TShaderProgramID:
            WriteParamValueReplay<ParamType::TShaderProgramID>(os, call,
                                                               param.value.ShaderProgramIDVal);
            break;
        case ParamType::TShaderProgramIDConstPointer:
            WriteParamValueReplay<ParamType::TShaderProgramIDConstPointer>(
                os, call, param.value.ShaderProgramIDConstPointerVal);
            break;
        case ParamType::TShaderProgramIDPointer:
            WriteParamValueReplay<ParamType::TShaderProgramIDPointer>(
                os, call, param.value.ShaderProgramIDPointerVal);
            break;
        case ParamType::TShaderType:
            WriteParamValueReplay<ParamType::TShaderType>(os, call, param.value.ShaderTypeVal);
            break;
        case ParamType::TShadingModel:
            WriteParamValueReplay<ParamType::TShadingModel>(os, call, param.value.ShadingModelVal);
            break;
        case ParamType::TShadingRate:
            WriteParamValueReplay<ParamType::TShadingRate>(os, call, param.value.ShadingRateVal);
            break;
        case ParamType::TSurfaceID:
            WriteParamValueReplay<ParamType::TSurfaceID>(os, call, param.value.SurfaceIDVal);
            break;
        case ParamType::TSyncID:
            WriteParamValueReplay<ParamType::TSyncID>(os, call, param.value.SyncIDVal);
            break;
        case ParamType::TTextureEnvParameter:
            WriteParamValueReplay<ParamType::TTextureEnvParameter>(
                os, call, param.value.TextureEnvParameterVal);
            break;
        case ParamType::TTextureEnvTarget:
            WriteParamValueReplay<ParamType::TTextureEnvTarget>(os, call,
                                                                param.value.TextureEnvTargetVal);
            break;
        case ParamType::TTextureID:
            WriteParamValueReplay<ParamType::TTextureID>(os, call, param.value.TextureIDVal);
            break;
        case ParamType::TTextureIDConstPointer:
            WriteParamValueReplay<ParamType::TTextureIDConstPointer>(
                os, call, param.value.TextureIDConstPointerVal);
            break;
        case ParamType::TTextureIDPointer:
            WriteParamValueReplay<ParamType::TTextureIDPointer>(os, call,
                                                                param.value.TextureIDPointerVal);
            break;
        case ParamType::TTextureImageParameter:
            WriteParamValueReplay<ParamType::TTextureImageParameter>(
                os, call, param.value.TextureImageParameterVal);
            break;
        case ParamType::TTextureTarget:
            WriteParamValueReplay<ParamType::TTextureTarget>(os, call,
                                                             param.value.TextureTargetVal);
            break;
        case ParamType::TTextureType:
            WriteParamValueReplay<ParamType::TTextureType>(os, call, param.value.TextureTypeVal);
            break;
        case ParamType::TTimestamp:
            WriteParamValueReplay<ParamType::TTimestamp>(os, call, param.value.TimestampVal);
            break;
        case ParamType::TTransformFeedbackID:
            WriteParamValueReplay<ParamType::TTransformFeedbackID>(
                os, call, param.value.TransformFeedbackIDVal);
            break;
        case ParamType::TTransformFeedbackIDConstPointer:
            WriteParamValueReplay<ParamType::TTransformFeedbackIDConstPointer>(
                os, call, param.value.TransformFeedbackIDConstPointerVal);
            break;
        case ParamType::TTransformFeedbackIDPointer:
            WriteParamValueReplay<ParamType::TTransformFeedbackIDPointer>(
                os, call, param.value.TransformFeedbackIDPointerVal);
            break;
        case ParamType::TUniformBlockIndex:
            WriteParamValueReplay<ParamType::TUniformBlockIndex>(os, call,
                                                                 param.value.UniformBlockIndexVal);
            break;
        case ParamType::TUniformBlockParameter:
            WriteParamValueReplay<ParamType::TUniformBlockParameter>(
                os, call, param.value.UniformBlockParameterVal);
            break;
        case ParamType::TUniformLocation:
            WriteParamValueReplay<ParamType::TUniformLocation>(os, call,
                                                               param.value.UniformLocationVal);
            break;
        case ParamType::TVertexArrayID:
            WriteParamValueReplay<ParamType::TVertexArrayID>(os, call,
                                                             param.value.VertexArrayIDVal);
            break;
        case ParamType::TVertexArrayIDConstPointer:
            WriteParamValueReplay<ParamType::TVertexArrayIDConstPointer>(
                os, call, param.value.VertexArrayIDConstPointerVal);
            break;
        case ParamType::TVertexArrayIDPointer:
            WriteParamValueReplay<ParamType::TVertexArrayIDPointer>(
                os, call, param.value.VertexArrayIDPointerVal);
            break;
        case ParamType::TVertexAttribType:
            WriteParamValueReplay<ParamType::TVertexAttribType>(os, call,
                                                                param.value.VertexAttribTypeVal);
            break;
        case ParamType::TcharConstPointer:
            WriteParamValueReplay<ParamType::TcharConstPointer>(os, call,
                                                                param.value.charConstPointerVal);
            break;
        case ParamType::Tegl_ConfigPointer:
            WriteParamValueReplay<ParamType::Tegl_ConfigPointer>(os, call,
                                                                 param.value.egl_ConfigPointerVal);
            break;
        case ParamType::Tegl_DevicePointer:
            WriteParamValueReplay<ParamType::Tegl_DevicePointer>(os, call,
                                                                 param.value.egl_DevicePointerVal);
            break;
        case ParamType::Tegl_DisplayPointer:
            WriteParamValueReplay<ParamType::Tegl_DisplayPointer>(
                os, call, param.value.egl_DisplayPointerVal);
            break;
        case ParamType::Tegl_StreamPointer:
            WriteParamValueReplay<ParamType::Tegl_StreamPointer>(os, call,
                                                                 param.value.egl_StreamPointerVal);
            break;
        case ParamType::Tegl_SyncID:
            WriteParamValueReplay<ParamType::Tegl_SyncID>(os, call, param.value.egl_SyncIDVal);
            break;
        case ParamType::TvoidConstPointer:
            WriteParamValueReplay<ParamType::TvoidConstPointer>(os, call,
                                                                param.value.voidConstPointerVal);
            break;
        case ParamType::TvoidConstPointerPointer:
            WriteParamValueReplay<ParamType::TvoidConstPointerPointer>(
                os, call, param.value.voidConstPointerPointerVal);
            break;
        case ParamType::TvoidPointer:
            WriteParamValueReplay<ParamType::TvoidPointer>(os, call, param.value.voidPointerVal);
            break;
        case ParamType::TvoidPointerPointer:
            WriteParamValueReplay<ParamType::TvoidPointerPointer>(
                os, call, param.value.voidPointerPointerVal);
            break;
#ifdef ANGLE_ENABLE_CL
        case ParamType::TAddressingMode:
            WriteParamValueReplay<ParamType::TAddressingMode>(os, call,
                                                              param.value.AddressingModeVal);
            break;
        case ParamType::TCommandQueueInfo:
            WriteParamValueReplay<ParamType::TCommandQueueInfo>(os, call,
                                                                param.value.CommandQueueInfoVal);
            break;
        case ParamType::TCommandQueueProperties:
            WriteParamValueReplay<ParamType::TCommandQueueProperties>(
                os, call, param.value.CommandQueuePropertiesVal);
            break;
        case ParamType::TContextInfo:
            WriteParamValueReplay<ParamType::TContextInfo>(os, call, param.value.ContextInfoVal);
            break;
        case ParamType::TDeviceInfo:
            WriteParamValueReplay<ParamType::TDeviceInfo>(os, call, param.value.DeviceInfoVal);
            break;
        case ParamType::TDeviceType:
            WriteParamValueReplay<ParamType::TDeviceType>(os, call, param.value.DeviceTypeVal);
            break;
        case ParamType::TEventInfo:
            WriteParamValueReplay<ParamType::TEventInfo>(os, call, param.value.EventInfoVal);
            break;
        case ParamType::TFilterMode:
            WriteParamValueReplay<ParamType::TFilterMode>(os, call, param.value.FilterModeVal);
            break;
        case ParamType::TImageInfo:
            WriteParamValueReplay<ParamType::TImageInfo>(os, call, param.value.ImageInfoVal);
            break;
        case ParamType::TKernelArgInfo:
            WriteParamValueReplay<ParamType::TKernelArgInfo>(os, call,
                                                             param.value.KernelArgInfoVal);
            break;
        case ParamType::TKernelExecInfo:
            WriteParamValueReplay<ParamType::TKernelExecInfo>(os, call,
                                                              param.value.KernelExecInfoVal);
            break;
        case ParamType::TKernelInfo:
            WriteParamValueReplay<ParamType::TKernelInfo>(os, call, param.value.KernelInfoVal);
            break;
        case ParamType::TKernelSubGroupInfo:
            WriteParamValueReplay<ParamType::TKernelSubGroupInfo>(
                os, call, param.value.KernelSubGroupInfoVal);
            break;
        case ParamType::TKernelWorkGroupInfo:
            WriteParamValueReplay<ParamType::TKernelWorkGroupInfo>(
                os, call, param.value.KernelWorkGroupInfoVal);
            break;
        case ParamType::TMapFlags:
            WriteParamValueReplay<ParamType::TMapFlags>(os, call, param.value.MapFlagsVal);
            break;
        case ParamType::TMemFlags:
            WriteParamValueReplay<ParamType::TMemFlags>(os, call, param.value.MemFlagsVal);
            break;
        case ParamType::TMemInfo:
            WriteParamValueReplay<ParamType::TMemInfo>(os, call, param.value.MemInfoVal);
            break;
        case ParamType::TMemMigrationFlags:
            WriteParamValueReplay<ParamType::TMemMigrationFlags>(os, call,
                                                                 param.value.MemMigrationFlagsVal);
            break;
        case ParamType::TMemObjectType:
            WriteParamValueReplay<ParamType::TMemObjectType>(os, call,
                                                             param.value.MemObjectTypeVal);
            break;
        case ParamType::TPipeInfo:
            WriteParamValueReplay<ParamType::TPipeInfo>(os, call, param.value.PipeInfoVal);
            break;
        case ParamType::TPlatformInfo:
            WriteParamValueReplay<ParamType::TPlatformInfo>(os, call, param.value.PlatformInfoVal);
            break;
        case ParamType::TProfilingInfo:
            WriteParamValueReplay<ParamType::TProfilingInfo>(os, call,
                                                             param.value.ProfilingInfoVal);
            break;
        case ParamType::TProgramBuildInfo:
            WriteParamValueReplay<ParamType::TProgramBuildInfo>(os, call,
                                                                param.value.ProgramBuildInfoVal);
            break;
        case ParamType::TProgramInfo:
            WriteParamValueReplay<ParamType::TProgramInfo>(os, call, param.value.ProgramInfoVal);
            break;
        case ParamType::TSVM_MemFlags:
            WriteParamValueReplay<ParamType::TSVM_MemFlags>(os, call, param.value.SVM_MemFlagsVal);
            break;
        case ParamType::TSamplerInfo:
            WriteParamValueReplay<ParamType::TSamplerInfo>(os, call, param.value.SamplerInfoVal);
            break;
        case ParamType::TcharConstPointerPointer:
            WriteParamValueReplay<ParamType::TcharConstPointerPointer>(
                os, call, param.value.charConstPointerPointerVal);
            break;
        case ParamType::TcharUnsignedConstPointerPointer:
            WriteParamValueReplay<ParamType::TcharUnsignedConstPointerPointer>(
                os, call, param.value.charUnsignedConstPointerPointerVal);
            break;
        case ParamType::Tcl_bool:
            WriteParamValueReplay<ParamType::Tcl_bool>(os, call, param.value.cl_boolVal);
            break;
        case ParamType::Tcl_buffer_create_type:
            WriteParamValueReplay<ParamType::Tcl_buffer_create_type>(
                os, call, param.value.cl_buffer_create_typeVal);
            break;
        case ParamType::Tcl_callback_func_type:
            WriteParamValueReplay<ParamType::Tcl_callback_func_type>(
                os, call, param.value.cl_callback_func_typeVal);
            break;
        case ParamType::Tcl_command_queue:
            WriteParamValueReplay<ParamType::Tcl_command_queue>(os, call,
                                                                param.value.cl_command_queueVal);
            break;
        case ParamType::Tcl_command_queue_propertiesPointer:
            WriteParamValueReplay<ParamType::Tcl_command_queue_propertiesPointer>(
                os, call, param.value.cl_command_queue_propertiesPointerVal);
            break;
        case ParamType::Tcl_context:
            WriteParamValueReplay<ParamType::Tcl_context>(os, call, param.value.cl_contextVal);
            break;
        case ParamType::Tcl_context_destructor_func_type:
            WriteParamValueReplay<ParamType::Tcl_context_destructor_func_type>(
                os, call, param.value.cl_context_destructor_func_typeVal);
            break;
        case ParamType::Tcl_context_func_type:
            WriteParamValueReplay<ParamType::Tcl_context_func_type>(
                os, call, param.value.cl_context_func_typeVal);
            break;
        case ParamType::Tcl_context_propertiesConstPointer:
            WriteParamValueReplay<ParamType::Tcl_context_propertiesConstPointer>(
                os, call, param.value.cl_context_propertiesConstPointerVal);
            break;
        case ParamType::Tcl_device_id:
            WriteParamValueReplay<ParamType::Tcl_device_id>(os, call, param.value.cl_device_idVal);
            break;
        case ParamType::Tcl_device_idConstPointer:
            WriteParamValueReplay<ParamType::Tcl_device_idConstPointer>(
                os, call, param.value.cl_device_idConstPointerVal);
            break;
        case ParamType::Tcl_device_idPointer:
            WriteParamValueReplay<ParamType::Tcl_device_idPointer>(
                os, call, param.value.cl_device_idPointerVal);
            break;
        case ParamType::Tcl_device_partition_propertyConstPointer:
            WriteParamValueReplay<ParamType::Tcl_device_partition_propertyConstPointer>(
                os, call, param.value.cl_device_partition_propertyConstPointerVal);
            break;
        case ParamType::Tcl_event:
            WriteParamValueReplay<ParamType::Tcl_event>(os, call, param.value.cl_eventVal);
            break;
        case ParamType::Tcl_eventConstPointer:
            WriteParamValueReplay<ParamType::Tcl_eventConstPointer>(
                os, call, param.value.cl_eventConstPointerVal);
            break;
        case ParamType::Tcl_eventPointer:
            WriteParamValueReplay<ParamType::Tcl_eventPointer>(os, call,
                                                               param.value.cl_eventPointerVal);
            break;
        case ParamType::Tcl_image_descConstPointer:
            WriteParamValueReplay<ParamType::Tcl_image_descConstPointer>(
                os, call, param.value.cl_image_descConstPointerVal);
            break;
        case ParamType::Tcl_image_formatConstPointer:
            WriteParamValueReplay<ParamType::Tcl_image_formatConstPointer>(
                os, call, param.value.cl_image_formatConstPointerVal);
            break;
        case ParamType::Tcl_image_formatPointer:
            WriteParamValueReplay<ParamType::Tcl_image_formatPointer>(
                os, call, param.value.cl_image_formatPointerVal);
            break;
        case ParamType::Tcl_import_properties_armConstPointer:
            WriteParamValueReplay<ParamType::Tcl_import_properties_armConstPointer>(
                os, call, param.value.cl_import_properties_armConstPointerVal);
            break;
        case ParamType::Tcl_int:
            WriteParamValueReplay<ParamType::Tcl_int>(os, call, param.value.cl_intVal);
            break;
        case ParamType::Tcl_intPointer:
            WriteParamValueReplay<ParamType::Tcl_intPointer>(os, call,
                                                             param.value.cl_intPointerVal);
            break;
        case ParamType::Tcl_kernel:
            WriteParamValueReplay<ParamType::Tcl_kernel>(os, call, param.value.cl_kernelVal);
            break;
        case ParamType::Tcl_kernelPointer:
            WriteParamValueReplay<ParamType::Tcl_kernelPointer>(os, call,
                                                                param.value.cl_kernelPointerVal);
            break;
        case ParamType::Tcl_mem:
            WriteParamValueReplay<ParamType::Tcl_mem>(os, call, param.value.cl_memVal);
            break;
        case ParamType::Tcl_memConstPointer:
            WriteParamValueReplay<ParamType::Tcl_memConstPointer>(
                os, call, param.value.cl_memConstPointerVal);
            break;
        case ParamType::Tcl_mem_destructor_func_type:
            WriteParamValueReplay<ParamType::Tcl_mem_destructor_func_type>(
                os, call, param.value.cl_mem_destructor_func_typeVal);
            break;
        case ParamType::Tcl_mem_propertiesConstPointer:
            WriteParamValueReplay<ParamType::Tcl_mem_propertiesConstPointer>(
                os, call, param.value.cl_mem_propertiesConstPointerVal);
            break;
        case ParamType::Tcl_pipe_propertiesConstPointer:
            WriteParamValueReplay<ParamType::Tcl_pipe_propertiesConstPointer>(
                os, call, param.value.cl_pipe_propertiesConstPointerVal);
            break;
        case ParamType::Tcl_platform_id:
            WriteParamValueReplay<ParamType::Tcl_platform_id>(os, call,
                                                              param.value.cl_platform_idVal);
            break;
        case ParamType::Tcl_platform_idPointer:
            WriteParamValueReplay<ParamType::Tcl_platform_idPointer>(
                os, call, param.value.cl_platform_idPointerVal);
            break;
        case ParamType::Tcl_program:
            WriteParamValueReplay<ParamType::Tcl_program>(os, call, param.value.cl_programVal);
            break;
        case ParamType::Tcl_programConstPointer:
            WriteParamValueReplay<ParamType::Tcl_programConstPointer>(
                os, call, param.value.cl_programConstPointerVal);
            break;
        case ParamType::Tcl_program_func_type:
            WriteParamValueReplay<ParamType::Tcl_program_func_type>(
                os, call, param.value.cl_program_func_typeVal);
            break;
        case ParamType::Tcl_queue_propertiesConstPointer:
            WriteParamValueReplay<ParamType::Tcl_queue_propertiesConstPointer>(
                os, call, param.value.cl_queue_propertiesConstPointerVal);
            break;
        case ParamType::Tcl_sampler:
            WriteParamValueReplay<ParamType::Tcl_sampler>(os, call, param.value.cl_samplerVal);
            break;
        case ParamType::Tcl_sampler_propertiesConstPointer:
            WriteParamValueReplay<ParamType::Tcl_sampler_propertiesConstPointer>(
                os, call, param.value.cl_sampler_propertiesConstPointerVal);
            break;
        case ParamType::Tcl_svm_free_callback_func_type:
            WriteParamValueReplay<ParamType::Tcl_svm_free_callback_func_type>(
                os, call, param.value.cl_svm_free_callback_func_typeVal);
            break;
        case ParamType::Tcl_uint:
            WriteParamValueReplay<ParamType::Tcl_uint>(os, call, param.value.cl_uintVal);
            break;
        case ParamType::Tcl_uintPointer:
            WriteParamValueReplay<ParamType::Tcl_uintPointer>(os, call,
                                                              param.value.cl_uintPointerVal);
            break;
        case ParamType::Tcl_ulongPointer:
            WriteParamValueReplay<ParamType::Tcl_ulongPointer>(os, call,
                                                               param.value.cl_ulongPointerVal);
            break;
        case ParamType::Tcl_void_func_type:
            WriteParamValueReplay<ParamType::Tcl_void_func_type>(os, call,
                                                                 param.value.cl_void_func_typeVal);
            break;
        case ParamType::Tsize_t:
            WriteParamValueReplay<ParamType::Tsize_t>(os, call, param.value.size_tVal);
            break;
        case ParamType::Tsize_tConstPointer:
            WriteParamValueReplay<ParamType::Tsize_tConstPointer>(
                os, call, param.value.size_tConstPointerVal);
            break;
        case ParamType::Tsize_tPointer:
            WriteParamValueReplay<ParamType::Tsize_tPointer>(os, call,
                                                             param.value.size_tPointerVal);
            break;
#endif
        default:
            os << "unknown";
            break;
    }
}

const char *ParamTypeToString(ParamType paramType)
{
    switch (paramType)
    {
        case ParamType::TAHardwareBufferConstPointer:
            return "const GLenum *";
        case ParamType::TAlphaTestFunc:
            return "GLenum";
        case ParamType::TBufferBinding:
            return "GLenum";
        case ParamType::TBufferID:
            return "GLuint";
        case ParamType::TBufferIDConstPointer:
            return "const GLuint *";
        case ParamType::TBufferIDPointer:
            return "GLuint *";
        case ParamType::TBufferParam:
            return "GLenum";
        case ParamType::TBufferUsage:
            return "GLenum";
        case ParamType::TClientVertexArrayType:
            return "GLenum";
        case ParamType::TClipDepthMode:
            return "GLenum";
        case ParamType::TClipOrigin:
            return "GLenum";
        case ParamType::TCombinerOp:
            return "GLenum";
        case ParamType::TCompositorTiming:
            return "GLenum";
        case ParamType::TContextID:
            return "GLuint";
        case ParamType::TCullFaceMode:
            return "GLenum";
        case ParamType::TDrawElementsType:
            return "GLenum";
        case ParamType::TEGLAttribConstPointer:
            return "const EGLAttrib *";
        case ParamType::TEGLAttribKHRPointer:
            return "EGLAttribKHR *";
        case ParamType::TEGLAttribPointer:
            return "EGLAttrib *";
        case ParamType::TEGLBoolean:
            return "EGLBoolean";
        case ParamType::TEGLBooleanPointer:
            return "EGLBoolean *";
        case ParamType::TEGLClientBuffer:
            return "EGLClientBuffer";
        case ParamType::TEGLConfigPointer:
            return "EGLConfig *";
        case ParamType::TEGLContext:
            return "EGLContext";
        case ParamType::TEGLDEBUGPROCKHR:
            return "EGLDEBUGPROCKHR";
        case ParamType::TEGLDeviceEXT:
            return "EGLDeviceEXT";
        case ParamType::TEGLDisplay:
            return "EGLDisplay";
        case ParamType::TEGLGetBlobFuncANDROID:
            return "EGLGetBlobFuncANDROID";
        case ParamType::TEGLImage:
            return "EGLImage";
        case ParamType::TEGLImageKHR:
            return "EGLImageKHR";
        case ParamType::TEGLLabelKHR:
            return "EGLLabelKHR";
        case ParamType::TEGLNativeDisplayType:
            return "EGLNativeDisplayType";
        case ParamType::TEGLNativePixmapType:
            return "EGLNativePixmapType";
        case ParamType::TEGLNativeWindowType:
            return "EGLNativeWindowType";
        case ParamType::TEGLObjectKHR:
            return "EGLObjectKHR";
        case ParamType::TEGLSetBlobFuncANDROID:
            return "EGLSetBlobFuncANDROID";
        case ParamType::TEGLStreamKHR:
            return "EGLStreamKHR";
        case ParamType::TEGLSurface:
            return "EGLSurface";
        case ParamType::TEGLSync:
            return "EGLSync";
        case ParamType::TEGLSyncKHR:
            return "EGLSyncKHR";
        case ParamType::TEGLTime:
            return "EGLTime";
        case ParamType::TEGLTimeKHR:
            return "EGLTimeKHR";
        case ParamType::TEGLenum:
            return "EGLenum";
        case ParamType::TEGLint:
            return "EGLint";
        case ParamType::TEGLintConstPointer:
            return "const EGLint *";
        case ParamType::TEGLintPointer:
            return "EGLint *";
        case ParamType::TEGLnsecsANDROID:
            return "EGLnsecsANDROID";
        case ParamType::TEGLnsecsANDROIDPointer:
            return "EGLnsecsANDROID *";
        case ParamType::TEGLuint64KHR:
            return "EGLuint64KHR";
        case ParamType::TEGLuint64KHRPointer:
            return "EGLuint64KHR *";
        case ParamType::TFenceNVID:
            return "GLuint";
        case ParamType::TFenceNVIDConstPointer:
            return "const GLuint *";
        case ParamType::TFenceNVIDPointer:
            return "GLuint *";
        case ParamType::TFramebufferID:
            return "GLuint";
        case ParamType::TFramebufferIDConstPointer:
            return "const GLuint *";
        case ParamType::TFramebufferIDPointer:
            return "GLuint *";
        case ParamType::TFramebufferParameter:
            return "GLenum";
        case ParamType::TGLDEBUGPROC:
            return "GLDEBUGPROC";
        case ParamType::TGLDEBUGPROCKHR:
            return "GLDEBUGPROCKHR";
        case ParamType::TGLGETBLOBPROCANGLE:
            return "GLGETBLOBPROCANGLE";
        case ParamType::TGLSETBLOBPROCANGLE:
            return "GLSETBLOBPROCANGLE";
        case ParamType::TGLbitfield:
            return "GLbitfield";
        case ParamType::TGLboolean:
            return "GLboolean";
        case ParamType::TGLbooleanPointer:
            return "GLboolean *";
        case ParamType::TGLcharConstPointer:
            return "const GLchar *";
        case ParamType::TGLcharConstPointerPointer:
            return "const GLchar *const *";
        case ParamType::TGLcharPointer:
            return "GLchar *";
        case ParamType::TGLclampx:
            return "GLclampx";
        case ParamType::TGLeglClientBufferEXT:
            return "GLeglClientBufferEXT";
        case ParamType::TGLenum:
            return "GLenum";
        case ParamType::TGLenumConstPointer:
            return "const GLenum *";
        case ParamType::TGLenumPointer:
            return "GLenum *";
        case ParamType::TGLfixed:
            return "GLfixed";
        case ParamType::TGLfixedConstPointer:
            return "const GLfixed *";
        case ParamType::TGLfixedPointer:
            return "GLfixed *";
        case ParamType::TGLfloat:
            return "GLfloat";
        case ParamType::TGLfloatConstPointer:
            return "const GLfloat *";
        case ParamType::TGLfloatPointer:
            return "GLfloat *";
        case ParamType::TGLint:
            return "GLint";
        case ParamType::TGLint64:
            return "GLint64";
        case ParamType::TGLint64Pointer:
            return "GLint64 *";
        case ParamType::TGLintConstPointer:
            return "const GLint *";
        case ParamType::TGLintPointer:
            return "GLint *";
        case ParamType::TGLintptr:
            return "GLintptr";
        case ParamType::TGLshort:
            return "GLshort";
        case ParamType::TGLshortConstPointer:
            return "const GLshort *";
        case ParamType::TGLsizei:
            return "GLsizei";
        case ParamType::TGLsizeiConstPointer:
            return "const GLsizei *";
        case ParamType::TGLsizeiPointer:
            return "GLsizei *";
        case ParamType::TGLsizeiptr:
            return "GLsizeiptr";
        case ParamType::TGLsync:
            return "GLsync";
        case ParamType::TGLubyte:
            return "GLubyte";
        case ParamType::TGLubyteConstPointer:
            return "const GLubyte *";
        case ParamType::TGLubytePointer:
            return "GLubyte *";
        case ParamType::TGLuint:
            return "GLuint";
        case ParamType::TGLuint64:
            return "GLuint64";
        case ParamType::TGLuint64ConstPointer:
            return "const GLuint64 *";
        case ParamType::TGLuint64Pointer:
            return "GLuint64 *";
        case ParamType::TGLuintConstPointer:
            return "const GLuint *";
        case ParamType::TGLuintPointer:
            return "GLuint *";
        case ParamType::TGraphicsResetStatus:
            return "GLenum";
        case ParamType::THandleType:
            return "GLenum";
        case ParamType::TImageID:
            return "GLuint";
        case ParamType::TLightParameter:
            return "GLenum";
        case ParamType::TLogicalOperation:
            return "GLenum";
        case ParamType::TMaterialParameter:
            return "GLenum";
        case ParamType::TMatrixType:
            return "GLenum";
        case ParamType::TMemoryObjectID:
            return "GLuint";
        case ParamType::TMemoryObjectIDConstPointer:
            return "const GLuint *";
        case ParamType::TMemoryObjectIDPointer:
            return "GLuint *";
        case ParamType::TObjectType:
            return "GLenum";
        case ParamType::TPackUnpackParameter:
            return "GLenum";
        case ParamType::TPlaneParameter:
            return "GLenum";
        case ParamType::TPointParameter:
            return "GLenum";
        case ParamType::TPolygonMode:
            return "GLenum";
        case ParamType::TPrimitiveMode:
            return "GLenum";
        case ParamType::TProgramPipelineID:
            return "GLuint";
        case ParamType::TProgramPipelineIDConstPointer:
            return "const GLuint *";
        case ParamType::TProgramPipelineIDPointer:
            return "GLuint *";
        case ParamType::TProvokingVertexConvention:
            return "GLenum";
        case ParamType::TQueryID:
            return "GLuint";
        case ParamType::TQueryIDConstPointer:
            return "const GLuint *";
        case ParamType::TQueryIDPointer:
            return "GLuint *";
        case ParamType::TQueryObjectParameter:
            return "GLenum";
        case ParamType::TQueryParameter:
            return "GLenum";
        case ParamType::TQueryType:
            return "GLenum";
        case ParamType::TRenderbufferID:
            return "GLuint";
        case ParamType::TRenderbufferIDConstPointer:
            return "const GLuint *";
        case ParamType::TRenderbufferIDPointer:
            return "GLuint *";
        case ParamType::TSamplerID:
            return "GLuint";
        case ParamType::TSamplerIDConstPointer:
            return "const GLuint *";
        case ParamType::TSamplerIDPointer:
            return "GLuint *";
        case ParamType::TSamplerParameter:
            return "GLenum";
        case ParamType::TSemaphoreID:
            return "GLuint";
        case ParamType::TSemaphoreIDConstPointer:
            return "const GLuint *";
        case ParamType::TSemaphoreIDPointer:
            return "GLuint *";
        case ParamType::TShaderParameter:
            return "GLenum";
        case ParamType::TShaderProgramID:
            return "GLuint";
        case ParamType::TShaderProgramIDConstPointer:
            return "const GLuint *";
        case ParamType::TShaderProgramIDPointer:
            return "GLuint *";
        case ParamType::TShaderType:
            return "GLenum";
        case ParamType::TShadingModel:
            return "GLenum";
        case ParamType::TShadingRate:
            return "GLenum";
        case ParamType::TSurfaceID:
            return "GLuint";
        case ParamType::TSyncID:
            return "GLuint";
        case ParamType::TTextureEnvParameter:
            return "GLenum";
        case ParamType::TTextureEnvTarget:
            return "GLenum";
        case ParamType::TTextureID:
            return "GLuint";
        case ParamType::TTextureIDConstPointer:
            return "const GLuint *";
        case ParamType::TTextureIDPointer:
            return "GLuint *";
        case ParamType::TTextureImageParameter:
            return "GLenum";
        case ParamType::TTextureTarget:
            return "GLenum";
        case ParamType::TTextureType:
            return "GLenum";
        case ParamType::TTimestamp:
            return "GLenum";
        case ParamType::TTransformFeedbackID:
            return "GLuint";
        case ParamType::TTransformFeedbackIDConstPointer:
            return "const GLuint *";
        case ParamType::TTransformFeedbackIDPointer:
            return "GLuint *";
        case ParamType::TUniformBlockIndex:
            return "GLenum";
        case ParamType::TUniformBlockParameter:
            return "GLenum";
        case ParamType::TUniformLocation:
            return "GLenum";
        case ParamType::TVertexArrayID:
            return "GLuint";
        case ParamType::TVertexArrayIDConstPointer:
            return "const GLuint *";
        case ParamType::TVertexArrayIDPointer:
            return "GLuint *";
        case ParamType::TVertexAttribType:
            return "GLenum";
        case ParamType::TcharConstPointer:
            return "const char *";
        case ParamType::Tegl_ConfigPointer:
            return "GLenum *";
        case ParamType::Tegl_DevicePointer:
            return "GLenum *";
        case ParamType::Tegl_DisplayPointer:
            return "GLenum *";
        case ParamType::Tegl_StreamPointer:
            return "GLenum *";
        case ParamType::Tegl_SyncID:
            return "GLuint";
        case ParamType::TvoidConstPointer:
            return "const void *";
        case ParamType::TvoidConstPointerPointer:
            return "const void **";
        case ParamType::TvoidPointer:
            return "void *";
        case ParamType::TvoidPointerPointer:
            return "void **";
        case ParamType::TAddressingMode:
            return "GLenum";
        case ParamType::TCommandQueueInfo:
            return "GLenum";
        case ParamType::TCommandQueueProperties:
            return "GLenum";
        case ParamType::TContextInfo:
            return "GLenum";
        case ParamType::TDeviceInfo:
            return "GLenum";
        case ParamType::TDeviceType:
            return "GLenum";
        case ParamType::TEventInfo:
            return "GLenum";
        case ParamType::TFilterMode:
            return "GLenum";
        case ParamType::TImageInfo:
            return "GLenum";
        case ParamType::TKernelArgInfo:
            return "GLenum";
        case ParamType::TKernelExecInfo:
            return "GLenum";
        case ParamType::TKernelInfo:
            return "GLenum";
        case ParamType::TKernelSubGroupInfo:
            return "GLenum";
        case ParamType::TKernelWorkGroupInfo:
            return "GLenum";
        case ParamType::TMapFlags:
            return "GLenum";
        case ParamType::TMemFlags:
            return "GLenum";
        case ParamType::TMemInfo:
            return "GLenum";
        case ParamType::TMemMigrationFlags:
            return "GLenum";
        case ParamType::TMemObjectType:
            return "GLenum";
        case ParamType::TPipeInfo:
            return "GLenum";
        case ParamType::TPlatformInfo:
            return "GLenum";
        case ParamType::TProfilingInfo:
            return "GLenum";
        case ParamType::TProgramBuildInfo:
            return "GLenum";
        case ParamType::TProgramInfo:
            return "GLenum";
        case ParamType::TSVM_MemFlags:
            return "GLenum";
        case ParamType::TSamplerInfo:
            return "GLenum";
        case ParamType::TcharConstPointerPointer:
            return "const char **";
        case ParamType::TcharUnsignedConstPointerPointer:
            return "const unsigned char **";
        case ParamType::Tcl_bool:
            return "cl_bool";
        case ParamType::Tcl_buffer_create_type:
            return "cl_buffer_create_type";
        case ParamType::Tcl_callback_func_type:
            return "cl_callback_func_type";
        case ParamType::Tcl_command_queue:
            return "cl_command_queue";
        case ParamType::Tcl_command_queue_propertiesPointer:
            return "cl_command_queue_properties *";
        case ParamType::Tcl_context:
            return "cl_context";
        case ParamType::Tcl_context_destructor_func_type:
            return "cl_context_destructor_func_type";
        case ParamType::Tcl_context_func_type:
            return "cl_context_func_type";
        case ParamType::Tcl_context_propertiesConstPointer:
            return "const cl_context_properties *";
        case ParamType::Tcl_device_id:
            return "cl_device_id";
        case ParamType::Tcl_device_idConstPointer:
            return "const cl_device_id *";
        case ParamType::Tcl_device_idPointer:
            return "cl_device_id *";
        case ParamType::Tcl_device_partition_propertyConstPointer:
            return "const cl_device_partition_property *";
        case ParamType::Tcl_event:
            return "cl_event";
        case ParamType::Tcl_eventConstPointer:
            return "const cl_event *";
        case ParamType::Tcl_eventPointer:
            return "cl_event *";
        case ParamType::Tcl_image_descConstPointer:
            return "const cl_image_desc *";
        case ParamType::Tcl_image_formatConstPointer:
            return "const cl_image_format *";
        case ParamType::Tcl_image_formatPointer:
            return "cl_image_format *";
        case ParamType::Tcl_import_properties_armConstPointer:
            return "const cl_import_properties_arm *";
        case ParamType::Tcl_int:
            return "cl_int";
        case ParamType::Tcl_intPointer:
            return "cl_int *";
        case ParamType::Tcl_kernel:
            return "cl_kernel";
        case ParamType::Tcl_kernelPointer:
            return "cl_kernel *";
        case ParamType::Tcl_mem:
            return "cl_mem";
        case ParamType::Tcl_memConstPointer:
            return "const cl_mem *";
        case ParamType::Tcl_mem_destructor_func_type:
            return "cl_mem_destructor_func_type";
        case ParamType::Tcl_mem_propertiesConstPointer:
            return "const cl_mem_properties *";
        case ParamType::Tcl_pipe_propertiesConstPointer:
            return "const cl_pipe_properties *";
        case ParamType::Tcl_platform_id:
            return "cl_platform_id";
        case ParamType::Tcl_platform_idPointer:
            return "cl_platform_id *";
        case ParamType::Tcl_program:
            return "cl_program";
        case ParamType::Tcl_programConstPointer:
            return "const cl_program *";
        case ParamType::Tcl_program_func_type:
            return "cl_program_func_type";
        case ParamType::Tcl_queue_propertiesConstPointer:
            return "const cl_queue_properties *";
        case ParamType::Tcl_sampler:
            return "cl_sampler";
        case ParamType::Tcl_sampler_propertiesConstPointer:
            return "const cl_sampler_properties *";
        case ParamType::Tcl_svm_free_callback_func_type:
            return "cl_svm_free_callback_func_type";
        case ParamType::Tcl_uint:
            return "cl_uint";
        case ParamType::Tcl_uintPointer:
            return "cl_uint *";
        case ParamType::Tcl_ulongPointer:
            return "cl_ulong *";
        case ParamType::Tcl_void_func_type:
            return "cl_void_func_type";
        case ParamType::Tsize_t:
            return "size_t";
        case ParamType::Tsize_tConstPointer:
            return "const size_t *";
        case ParamType::Tsize_tPointer:
            return "size_t *";
        default:
            UNREACHABLE();
            return "unknown";
    }
}

ResourceIDType GetResourceIDTypeFromParamType(ParamType paramType)
{
    switch (paramType)
    {
        case ParamType::TBufferID:
            return ResourceIDType::Buffer;
        case ParamType::TBufferIDConstPointer:
            return ResourceIDType::Buffer;
        case ParamType::TBufferIDPointer:
            return ResourceIDType::Buffer;
        case ParamType::TContextID:
            return ResourceIDType::Context;
        case ParamType::TFenceNVID:
            return ResourceIDType::FenceNV;
        case ParamType::TFenceNVIDConstPointer:
            return ResourceIDType::FenceNV;
        case ParamType::TFenceNVIDPointer:
            return ResourceIDType::FenceNV;
        case ParamType::TFramebufferID:
            return ResourceIDType::Framebuffer;
        case ParamType::TFramebufferIDConstPointer:
            return ResourceIDType::Framebuffer;
        case ParamType::TFramebufferIDPointer:
            return ResourceIDType::Framebuffer;
        case ParamType::TImageID:
            return ResourceIDType::Image;
        case ParamType::TMemoryObjectID:
            return ResourceIDType::MemoryObject;
        case ParamType::TMemoryObjectIDConstPointer:
            return ResourceIDType::MemoryObject;
        case ParamType::TMemoryObjectIDPointer:
            return ResourceIDType::MemoryObject;
        case ParamType::TProgramPipelineID:
            return ResourceIDType::ProgramPipeline;
        case ParamType::TProgramPipelineIDConstPointer:
            return ResourceIDType::ProgramPipeline;
        case ParamType::TProgramPipelineIDPointer:
            return ResourceIDType::ProgramPipeline;
        case ParamType::TQueryID:
            return ResourceIDType::Query;
        case ParamType::TQueryIDConstPointer:
            return ResourceIDType::Query;
        case ParamType::TQueryIDPointer:
            return ResourceIDType::Query;
        case ParamType::TRenderbufferID:
            return ResourceIDType::Renderbuffer;
        case ParamType::TRenderbufferIDConstPointer:
            return ResourceIDType::Renderbuffer;
        case ParamType::TRenderbufferIDPointer:
            return ResourceIDType::Renderbuffer;
        case ParamType::TSamplerID:
            return ResourceIDType::Sampler;
        case ParamType::TSamplerIDConstPointer:
            return ResourceIDType::Sampler;
        case ParamType::TSamplerIDPointer:
            return ResourceIDType::Sampler;
        case ParamType::TSemaphoreID:
            return ResourceIDType::Semaphore;
        case ParamType::TSemaphoreIDConstPointer:
            return ResourceIDType::Semaphore;
        case ParamType::TSemaphoreIDPointer:
            return ResourceIDType::Semaphore;
        case ParamType::TShaderProgramID:
            return ResourceIDType::ShaderProgram;
        case ParamType::TShaderProgramIDConstPointer:
            return ResourceIDType::ShaderProgram;
        case ParamType::TShaderProgramIDPointer:
            return ResourceIDType::ShaderProgram;
        case ParamType::TSurfaceID:
            return ResourceIDType::Surface;
        case ParamType::TSyncID:
            return ResourceIDType::Sync;
        case ParamType::TTextureID:
            return ResourceIDType::Texture;
        case ParamType::TTextureIDConstPointer:
            return ResourceIDType::Texture;
        case ParamType::TTextureIDPointer:
            return ResourceIDType::Texture;
        case ParamType::TTransformFeedbackID:
            return ResourceIDType::TransformFeedback;
        case ParamType::TTransformFeedbackIDConstPointer:
            return ResourceIDType::TransformFeedback;
        case ParamType::TTransformFeedbackIDPointer:
            return ResourceIDType::TransformFeedback;
        case ParamType::TVertexArrayID:
            return ResourceIDType::VertexArray;
        case ParamType::TVertexArrayIDConstPointer:
            return ResourceIDType::VertexArray;
        case ParamType::TVertexArrayIDPointer:
            return ResourceIDType::VertexArray;
        case ParamType::Tegl_SyncID:
            return ResourceIDType::egl_Sync;

        default:
            return ResourceIDType::InvalidEnum;
    }
}

const char *GetResourceIDTypeName(ResourceIDType resourceIDType)
{
    switch (resourceIDType)
    {
        case ResourceIDType::Buffer:
            return "Buffer";
        case ResourceIDType::Context:
            return "Context";
        case ResourceIDType::FenceNV:
            return "FenceNV";
        case ResourceIDType::Framebuffer:
            return "Framebuffer";
        case ResourceIDType::Image:
            return "Image";
        case ResourceIDType::MemoryObject:
            return "MemoryObject";
        case ResourceIDType::ProgramPipeline:
            return "ProgramPipeline";
        case ResourceIDType::Query:
            return "Query";
        case ResourceIDType::Renderbuffer:
            return "Renderbuffer";
        case ResourceIDType::Sampler:
            return "Sampler";
        case ResourceIDType::Semaphore:
            return "Semaphore";
        case ResourceIDType::ShaderProgram:
            return "ShaderProgram";
        case ResourceIDType::Surface:
            return "Surface";
        case ResourceIDType::Sync:
            return "Sync";
        case ResourceIDType::Texture:
            return "Texture";
        case ResourceIDType::TransformFeedback:
            return "TransformFeedback";
        case ResourceIDType::VertexArray:
            return "VertexArray";
        case ResourceIDType::egl_Sync:
            return "egl_Sync";

        default:
            UNREACHABLE();
            return "GetResourceIDTypeName error";
    }
}
}  // namespace angle